feat: drawing theoretically implemented

in practice not working.

Author: Torwent

src/client/graphics.rs

@@ -7,13 +7,17 @@ use std::{
 
 use gl::{
     types::{GLboolean, GLchar, GLenum, GLfloat, GLint, GLsizei, GLsizeiptr, GLuint, GLvoid},
-    BGRA, FRAGMENT_SHADER, PIXEL_PACK_BUFFER, POINTS, READ_ONLY, STREAM_READ, UNSIGNED_BYTE,
-    VERTEX_SHADER,
+    BGRA, CLAMP_TO_EDGE, FRAGMENT_SHADER, LINEAR, PIXEL_PACK_BUFFER, POINTS, READ_ONLY, RGBA8,
+    STREAM_READ, TEXTURE0, TEXTURE_2D, TEXTURE_MAG_FILTER, TEXTURE_MIN_FILTER, TEXTURE_WRAP_S,
+    TEXTURE_WRAP_T, TRIANGLE_STRIP, UNSIGNED_BYTE, VERTEX_SHADER,
 };
 
 use windows::{
     core::PCSTR,
-    Win32::Graphics::OpenGL::{glDrawArrays, glPointSize, glReadPixels, wglGetProcAddress},
+    Win32::Graphics::OpenGL::{
+        glBindTexture, glDrawArrays, glGenTextures, glPointSize, glReadPixels, glTexParameteri,
+        glTexSubImage2D, glViewport, wglGetProcAddress,
+    },
 };
 
 type GlGenBuffersFn = unsafe extern "system" fn(n: GLsizei, buffers: *mut GLuint);
@@ -36,13 +40,23 @@ type GlAttachShaderFn = unsafe extern "system" fn(program: GLuint, shader: GLuin
 type GlLinkProgramFn = unsafe extern "system" fn(program: GLuint);
 type GlDeleteShaderFn = unsafe extern "system" fn(shader: GLuint);
 type GlBindVertexArrayFn = unsafe extern "system" fn(array: GLuint);
-
 type GlUseProgramFn = unsafe extern "system" fn(program: GLuint);
-
-type GlCreateVertexArrays = unsafe extern "system" fn(n: GLsizei, arrays: *mut GLuint);
-
-type GLUniform2Fv =
+type GlCreateVertexArraysFn = unsafe extern "system" fn(n: GLsizei, arrays: *mut GLuint);
+type GlGenVertexArraysFn = unsafe extern "system" fn(n: GLsizei, arrays: *mut GLuint);
+type GLUniform2FvFn =
     unsafe extern "system" fn(location: GLint, count: GLsizei, value: *const GLfloat);
+type GLTexStorage2DFn = unsafe extern "system" fn(
+    target: GLenum,
+    levels: GLsizei,
+    internalformat: GLenum,
+    width: GLsizei,
+    height: GLsizei,
+);
+type GLActiveTextureFn = unsafe extern "system" fn(texture: GLenum);
+type GLBindTextureFn = unsafe extern "system" fn(target: GLenum, texture: GLuint);
+type GLUniform1iFn = unsafe extern "system" fn(location: GLint, v0: GLint);
+type GLGetUniformLocationFn =
+    unsafe extern "system" fn(program: GLuint, name: *const GLchar) -> GLint;
 
 static GL_GEN_BUFFERS: OnceLock<GlGenBuffersFn> = OnceLock::new();
 static GL_DELETE_BUFFERS: OnceLock<GlDeleteBuffersFn> = OnceLock::new();
@@ -59,11 +73,19 @@ static GL_LINK_PROGRAM: OnceLock<GlLinkProgramFn> = OnceLock::new();
 static GL_DELETE_SHADER: OnceLock<GlDeleteShaderFn> = OnceLock::new();
 static GL_BIND_VERTEX_ARRAY: OnceLock<GlBindVertexArrayFn> = OnceLock::new();
 static GL_USE_PROGRAM: OnceLock<GlUseProgramFn> = OnceLock::new();
-static GL_CREATE_VERTEX_ARRAYS: OnceLock<GlCreateVertexArrays> = OnceLock::new();
-static GL_UNIFORM_2FV: OnceLock<GLUniform2Fv> = OnceLock::new();
-
-static SHADER_PROGRAM: OnceLock<GLuint> = OnceLock::new();
+static GL_CREATE_VERTEX_ARRAYS: OnceLock<GlCreateVertexArraysFn> = OnceLock::new();
+static GL_GEN_VERTEX_ARRAYS: OnceLock<GlGenVertexArraysFn> = OnceLock::new();
+static GL_UNIFORM_2FV: OnceLock<GLUniform2FvFn> = OnceLock::new();
+static GL_TEX_STORAGE_2D: OnceLock<GLTexStorage2DFn> = OnceLock::new();
+static GL_ACTIVE_TEXTURE: OnceLock<GLActiveTextureFn> = OnceLock::new();
+static GL_BIND_TEXTURE: OnceLock<GLBindTextureFn> = OnceLock::new();
+static GL_UNIFORM_1I: OnceLock<GLUniform1iFn> = OnceLock::new();
+static GL_GET_UNIFORM_LOCATION: OnceLock<GLGetUniformLocationFn> = OnceLock::new();
+
+static POINT_SHADER: OnceLock<GLuint> = OnceLock::new();
 static VAO: OnceLock<GLuint> = OnceLock::new();
+static OVERLAY_SHADER: OnceLock<GLuint> = OnceLock::new();
+static TEXTURE: OnceLock<GLuint> = OnceLock::new();
 
 pub fn restore_state(prev_program: i32, prev_vao: i32) {
     let use_program = *GL_USE_PROGRAM.get().unwrap();
@@ -122,14 +144,28 @@ pub unsafe fn load_opengl_extensions() -> bool {
         && load!(GL_USE_PROGRAM, GlUseProgramFn, "glUseProgram")
         && load!(
             GL_CREATE_VERTEX_ARRAYS,
-            GlCreateVertexArrays,
+            GlCreateVertexArraysFn,
             "glCreateVertexArrays"
         )
-        && load!(GL_UNIFORM_2FV, GLUniform2Fv, "glUniform2fv")
+        && load!(
+            GL_GEN_VERTEX_ARRAYS,
+            GlGenVertexArraysFn,
+            "glGenVertexArrays"
+        )
+        && load!(GL_UNIFORM_2FV, GLUniform2FvFn, "glUniform2fv")
+        && load!(GL_TEX_STORAGE_2D, GLTexStorage2DFn, "glTexStorage2D")
+        && load!(GL_ACTIVE_TEXTURE, GLActiveTextureFn, "glActiveTexture")
+        && load!(GL_BIND_TEXTURE, GLBindTextureFn, "glBindTexture")
+        && load!(GL_UNIFORM_1I, GLUniform1iFn, "glUniform1i")
+        && load!(
+            GL_GET_UNIFORM_LOCATION,
+            GLGetUniformLocationFn,
+            "glGetUniformLocation"
+        )
 }
 
 lazy_static! {
-    static ref PBO_DATA: Mutex<(Vec<u32>, i32, usize)> = Mutex::new((vec![0, 0], 0, 0)); // (PBOs, size, index)
+    static ref PBO_DATA: Mutex<(Vec<u32>, i32, usize)> = Mutex::new((vec![0, 0], 0, 0)); //(PBOs, size, index)
 }
 
 pub fn read_frame(width: i32, height: i32, size: i32, dest: *mut u8) {
@@ -197,17 +233,6 @@ pub fn read_frame(width: i32, height: i32, size: i32, dest: *mut u8) {
     }
 }
 
-/* fn print_gl_errors(name: &str) {
-    loop {
-        let error = unsafe { glGetError() };
-        if error == GL_NO_ERROR {
-            break;
-        }
-        println!("{} error: {:x}\r\n", name, error);
-    }
-}
- */
-
 fn compile_shader(source: &str, shader_type: GLenum) -> GLuint {
     let gl_create_shader = *GL_CREATE_SHADER.get().unwrap();
     let gl_shader_source = *GL_SHADER_SOURCE.get().unwrap();
@@ -223,12 +248,125 @@ fn compile_shader(source: &str, shader_type: GLenum) -> GLuint {
     }
 }
 
+fn init_gl_resources_overlay() {
+    let create_program = *GL_CREATE_PROGRAM.get().unwrap();
+    let gen_vertex_arrays = *GL_GEN_VERTEX_ARRAYS.get().unwrap();
+    let attach_shader = *GL_ATTACH_SHADER.get().unwrap();
+    let link_program = *GL_LINK_PROGRAM.get().unwrap();
+    let delete_shader = *GL_DELETE_SHADER.get().unwrap();
+
+    const VS_SRC: &str = r#"
+    #version 460 core
+    const vec2 verts[4] = vec2[4](
+        vec2(-1.0, -1.0),
+        vec2( 1.0, -1.0),
+        vec2(-1.0,  1.0),
+        vec2( 1.0,  1.0)
+    );
+    out vec2 texCoord;
+    void main() {
+        texCoord = (verts[gl_VertexID].xy + 1.0) * 0.5;
+        gl_Position = vec4(verts[gl_VertexID], 0.0, 1.0);
+    }"#;
+
+    const FS_SRC: &str = r#"
+    #version 460 core
+    in vec2 texCoord;
+    out vec4 FragColor;
+    uniform sampler2D screenTex;
+    void main() {
+        FragColor = texture(screenTex, vec2(texCoord.x, 1.0 - texCoord.y));
+    }"#;
+
+    let vs = compile_shader(VS_SRC, VERTEX_SHADER);
+    let fs = compile_shader(FS_SRC, FRAGMENT_SHADER);
+
+    unsafe {
+        let program = create_program();
+        attach_shader(program, vs);
+        attach_shader(program, fs);
+        link_program(program);
+
+        delete_shader(vs);
+        delete_shader(fs);
+        OVERLAY_SHADER.set(program).unwrap();
+    };
+
+    if VAO.get().is_none() {
+        let mut vao = 0;
+        unsafe { gen_vertex_arrays(1, &mut vao) };
+        VAO.set(vao).unwrap();
+    }
+}
+
+fn init_gl_texture(width: i32, height: i32) {
+    let gl_tex_storage_2d = *GL_TEX_STORAGE_2D.get().unwrap();
+    let mut texture: GLuint = 0;
+    unsafe {
+        glGenTextures(1, &mut texture);
+        glBindTexture(TEXTURE_2D, texture);
+        glTexParameteri(TEXTURE_2D, TEXTURE_MIN_FILTER, LINEAR as i32);
+        glTexParameteri(TEXTURE_2D, TEXTURE_MAG_FILTER, LINEAR as i32);
+        glTexParameteri(TEXTURE_2D, TEXTURE_WRAP_S, CLAMP_TO_EDGE as i32);
+        glTexParameteri(TEXTURE_2D, TEXTURE_WRAP_T, CLAMP_TO_EDGE as i32);
+        gl_tex_storage_2d(TEXTURE_2D, 1, RGBA8, width, height);
+    };
+    TEXTURE.set(texture).unwrap();
+}
+
+pub fn draw_overlay(width: i32, height: i32, src: *const u8) {
+    if OVERLAY_SHADER.get().is_none() {
+        init_gl_resources_overlay();
+    }
+
+    if TEXTURE.get().is_none() {
+        init_gl_texture(width, height);
+    }
+
+    let use_program = *GL_USE_PROGRAM.get().unwrap();
+    let active_texture = *GL_ACTIVE_TEXTURE.get().unwrap();
+    let bind_texture = *GL_BIND_TEXTURE.get().unwrap();
+    let uniform_1i = *GL_UNIFORM_1I.get().unwrap();
+    let get_uniform_location = *GL_GET_UNIFORM_LOCATION.get().unwrap();
+    let bind_vertex_array = *GL_BIND_VERTEX_ARRAY.get().unwrap();
+
+    let program = *OVERLAY_SHADER.get().unwrap();
+    let texture = *TEXTURE.get().unwrap();
+    let vao = *VAO.get().unwrap();
+
+    // Upload new data every frame
+    unsafe {
+        glViewport(0, 0, width, height);
+        glBindTexture(TEXTURE_2D, texture);
+        glTexSubImage2D(
+            TEXTURE_2D,
+            0,
+            0,
+            0,
+            width,
+            height,
+            BGRA,
+            UNSIGNED_BYTE,
+            src as *const c_void,
+        );
+
+        use_program(program);
+        active_texture(TEXTURE0);
+        bind_texture(TEXTURE_2D, texture);
+        let name = CString::new("screenTex").unwrap();
+        uniform_1i(get_uniform_location(program, name.as_ptr()), 0);
+
+        bind_vertex_array(vao);
+        glDrawArrays(TRIANGLE_STRIP, 0, 4);
+    }
+}
+
 fn init_gl_resources() {
-    let gl_create_program = *GL_CREATE_PROGRAM.get().unwrap();
-    let gl_attach_shader = *GL_ATTACH_SHADER.get().unwrap();
-    let gl_link_program = *GL_LINK_PROGRAM.get().unwrap();
-    let gl_delete_shader = *GL_DELETE_SHADER.get().unwrap();
-    let gl_create_vertex_arrays = *GL_CREATE_VERTEX_ARRAYS.get().unwrap();
+    let create_program = *GL_CREATE_PROGRAM.get().unwrap();
+    let attach_shader = *GL_ATTACH_SHADER.get().unwrap();
+    let link_program = *GL_LINK_PROGRAM.get().unwrap();
+    let delete_shader = *GL_DELETE_SHADER.get().unwrap();
+    let gen_vertex_arrays = *GL_GEN_VERTEX_ARRAYS.get().unwrap();
 
     const VS_SRC: &str = r#"
     #version 460 core
@@ -251,32 +389,34 @@ fn init_gl_resources() {
     let fs = compile_shader(FS_SRC, FRAGMENT_SHADER);
 
     unsafe {
-        let program = gl_create_program();
-        gl_attach_shader(program, vs);
-        gl_attach_shader(program, fs);
-        gl_link_program(program);
+        let program = create_program();
+        attach_shader(program, vs);
+        attach_shader(program, fs);
+        link_program(program);
 
-        gl_delete_shader(vs);
-        gl_delete_shader(fs);
+        delete_shader(vs);
+        delete_shader(fs);
 
-        let mut vao = 0;
-        gl_create_vertex_arrays(1, &mut vao);
+        POINT_SHADER.set(program).unwrap();
+    };
 
-        SHADER_PROGRAM.set(program).unwrap();
+    if VAO.get().is_none() {
+        let mut vao = 0;
+        unsafe { gen_vertex_arrays(1, &mut vao) };
         VAO.set(vao).unwrap();
-    };
+    }
 }
 
 pub fn draw_point(x: i32, y: i32, w: i32, h: i32) {
-    if SHADER_PROGRAM.get().is_none() {
+    if POINT_SHADER.get().is_none() {
         init_gl_resources();
     }
 
     let use_program = *GL_USE_PROGRAM.get().unwrap();
     let bind_vertex_array = *GL_BIND_VERTEX_ARRAY.get().unwrap();
     let uniform_2fv = *GL_UNIFORM_2FV.get().unwrap();
 
-    let program = *SHADER_PROGRAM.get().unwrap();
+    let program = *POINT_SHADER.get().unwrap();
     let vao = *VAO.get().unwrap();
 
     let x_ndc = (x as f32 / w as f32) * 2.0 - 1.0;

src/client/hooks.rs

@@ -34,7 +34,9 @@ use windows::{
     },
 };
 
-use super::graphics::{draw_point, load_opengl_extensions, read_frame, restore_state};
+use super::graphics::{
+    draw_overlay, draw_point, load_opengl_extensions, read_frame, restore_state,
+};
 use crate::shared::{
     memory::{MemoryManager, MEMORY_MANAGER},
     windows::{WI_CONSOLE, WI_MODIFIERS, WI_REMAP},
@@ -297,11 +299,15 @@ unsafe extern "system" fn hooked_wgl_swap_buffers(hdc: HDC) -> BOOL {
     let height = viewport[3];
     let frame_size = width * height * 4;
 
-    mem_manager.set_dimensions(width, height, frame_size);
+    mem_manager.set_dimensions(width, height);
 
     if load_opengl_extensions() {
         let dest = mem_manager.image_ptr();
         read_frame(width, height, frame_size, dest);
+
+        let overlay = mem_manager.overlay_ptr();
+        draw_overlay(width, height, overlay);
+
         if (mouse.0 > -1) && (mouse.1 > -1) && (mouse.0 < width) && (mouse.1 < height) {
             draw_point(mouse.0, mouse.1, width, height);
         }

src/shared/memory.rs

@@ -22,8 +22,8 @@ pub struct SharedMemory {
     pub mouse_y: i32,
     pub width: i32,
     pub height: i32,
-    pub img_size: i32,
     pub img: [u8; IMAGE_DATA_SIZE],
+    pub overlay: [u8; IMAGE_DATA_SIZE],
 }
 
 pub struct MemoryManager {
@@ -100,6 +100,10 @@ impl MemoryManager {
         (*self.ptr).img.as_ptr() as *mut u8
     }
 
+    pub unsafe fn overlay_ptr(&self) -> *mut u8 {
+        (*self.ptr).overlay.as_ptr() as *mut u8
+    }
+
     pub unsafe fn get_mouse_position(&self) -> (i32, i32) {
         ((*self.ptr).mouse_x, (*self.ptr).mouse_y)
     }
@@ -113,10 +117,9 @@ impl MemoryManager {
         ((*self.ptr).width, (*self.ptr).height)
     }
 
-    pub unsafe fn set_dimensions(&self, width: i32, height: i32, frame_size: i32) {
+    pub unsafe fn set_dimensions(&self, width: i32, height: i32) {
         (*self.ptr).width = width;
         (*self.ptr).height = height;
-        (*self.ptr).img_size = frame_size;
     }
 }