Как спроецировать 2D-текст на трехмерную проекцию мирового пространства? ⇐ Python

[Anonymous]

includes/GLArcball.py:

Код: Выделить всё

import glm
import numpy as np

class GLArcball:
def __init__(self, eye, center, up):
self.eye = eye
self.center = center
self.up = up

dir = center - eye
z_ax = glm.normalize(dir)
x_ax = glm.normalize(glm.cross(z_ax, glm.normalize(up)))
y_ax = glm.normalize(glm.cross(x_ax, z_ax))
x_ax = glm.normalize(glm.cross(z_ax, y_ax))

self.center_translation = glm.inverse(glm.translate(center))
self.translation = glm.translate(glm.vec3(0.0, 0.0, -glm.length(dir)))
self.rotation = glm.normalize(glm.quat_cast(glm.transpose(glm.mat3(x_ax, y_ax, -z_ax))))

self.update_camera()

def update_camera(self):
self.camera = self.translation * glm.mat4_cast(self.rotation) * self.center_translation
self.inv_camera = glm.inverse(self.camera)

def transform(self):
return self.camera

def rotate(self, prev_mouse, cur_mouse):
cur_mouse = glm.clamp(cur_mouse, glm.vec2(-1, -1), glm.vec2(1, 1))
prev_mouse = glm.clamp(prev_mouse, glm.vec2(-1, -1), glm.vec2(1, 1))

mouse_cur_ball = self.screen_to_arcball(cur_mouse)
mouse_prev_ball = self.screen_to_arcball(prev_mouse)

rotation = mouse_cur_ball * glm.inverse(mouse_prev_ball)
self.rotation = rotation * self.rotation

self.update_camera()

def angle_between(self, v1, v2):
dot_product = glm.dot(v1, v2)
lengths = glm.length(v1) * glm.length(v2)
value = glm.clamp(dot_product / lengths, -1.0, 1.0)
return glm.acos(value)

def screen_to_arcball(self, p):
dist = glm.dot(p, p)
if dist   None:
glViewport(0, 0, width, height)

def main():
win_width, win_height, window = init_glfw("LearnOpenGL")
global bufs_enum
bufs_enum = init_buffers(2100000, 2100000)
view_state['window_width'] = win_width
view_state['window_height'] = win_height
view_state['view_width'] = win_width * .15
view_state['view_height'] = win_height * .15
view_state['lookAt'] = glm.mat4(1.0)
view_state['lookAt'] = glm.lookAt(glm.vec3(0, 0, 1000), glm.vec3(0, 0, 0), glm.vec3(0, 1, 0))
view_state['ortho'] = glm.ortho(-(view_state['window_width'] / 2), view_state['window_width'] / 2,
-(view_state['window_height'] / 2), view_state['window_height'] / 2, view_state['near'], view_state['far'])

glfwSetScrollCallback(window, scrollwheel_callback)
glfwSetWindowAspectRatio(window, int(win_width), int(win_height))
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback)
glfwSetKeyCallback(window, key_callback)
glfwSetMouseButtonCallback(window, mouse_button_callback)
glfwSetCursorPosCallback(window, mouse_callback)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glViewport(0, 0, win_width, win_height)

init_objects(bufs_enum)

while not glfwWindowShouldClose(window):
render(window)

glfwTerminate()
print('done...')

def init_objects(bufs_enum):
global vbo_start
vbo_start = 0
global ebo_start
ebo_start = 0

global objects_dict
objects_dict = {}
rect_grid = GLRectGrid(32,32,4,8,[1,0,0,1],vbo_start, ebo_start)
rect_grid.buffer_vbo(bufs_enum)
rect_grid.model = glm.scale( rect_grid.model, glm.vec3( 100, 100, 0))

vbo_start = rect_grid.vbo_end
ebo_start = rect_grid.ebo_end

objects_dict['hexahedron_region'] = {
'object': rect_grid,
'vbo_start': None,
'ebo_Start': None,
'vbo_end': None,
'ebo_end': None
}

rect_grid_text_points = rect_grid.getTransformedPoints(camera.transform(), view_state['ortho'],
view_state['window_width'], view_state['window_height'])

global texts
texts = []
for i, point in enumerate(rect_grid_text_points):
print(point)
text = GLTextImage(vbo_start, ebo_start)
text.loadText(str(i), 'C:\\Windows\\Fonts\\Arial.ttf', 15, (255, 255, 255, 255))
text.bufferData(bufs_enum)
vbo_start=text.vbo_end
ebo_start=text.ebo_end
text.model = glm.translate(text.model, glm.vec3(point[0], point[1], point[2]))
text.model = glm.translate(text.model, glm.vec3(-(view_state['window_width']/2),-(view_state['window_height']/2),0.0))
##text.model = glm.scale( text.model, glm.vec3( .01, .01, 0.0))
texts.append(text)

def render(window):
last_frame = glfwGetTime()
while not glfwWindowShouldClose(window):
current_time = glfwGetTime()
delta_time = current_time - last_frame
last_frame = current_time

# Render
glClearColor(0.2, 0.3, 0.3, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
objects_dict['hexahedron_region']['object'].draw(bufs_enum, 3.0, camera.transform(), view_state['ortho'])
#obj_dict['hexahedron_region']['object'].drawTextNodes(-.125, .125, bufs_enum, 3.0,
#                                                      camera.transform(), view_state['ortho'], view_state['ortho'])

global texts
for text in texts:
text.drawText(bufs_enum, camera.transform(), view_state['ortho'])

glfwSwapBuffers(window)
glfwPollEvents()

if __name__ == "__main__":
main()

Начало инициализации:
1


При вращении GLArcBall расположение текста смещается дальше. Почему? Как это предотвратить?
2


Как заставить текст оставаться непосредственно на узлах?
Python 3.11.9+-
До сих пор я пробовал множество различных методов аннотируйте текст прямо над узлами при вращении GLArcBall. Я ожидал, что текст будет отображаться прямо поверх узлов при вращении GLArcBall.

Подробнее здесь: https://stackoverflow.com/questions/786 ... projection