mirror of
https://github.com/cyberboy666/r_e_c_u_r.git
synced 2025-12-23 08:40:05 +01:00
some stuff from when i last worked on conjur
This commit is contained in:
langolierz
@@ -1,196 +0,0 @@
|
||||
# Pygame/PyopenGL example by Bastiaan Zapf, Apr 2009
|
||||
#
|
||||
# Draw a range of cubes, light them prettily
|
||||
#
|
||||
# Employed techniques:
|
||||
#
|
||||
# - Vertex and Fragment shaders
|
||||
# - Lightsource variables
|
||||
# - Display Lists
|
||||
|
||||
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
import random
|
||||
from math import * # trigonometry
|
||||
|
||||
import pygame # just to get a display
|
||||
|
||||
import Image
|
||||
import sys
|
||||
import time
|
||||
|
||||
# get an OpenGL surface
|
||||
|
||||
pygame.init()
|
||||
pygame.display.set_mode((800,600), pygame.OPENGL|pygame.DOUBLEBUF)
|
||||
|
||||
def jpg_file_write(name, number, data):
|
||||
im = Image.frombuffer("RGBA", (800,600), data, "raw", "RGBA", 0, 0)
|
||||
fnumber = "%05d" % number
|
||||
im.save(name + fnumber + ".jpg")
|
||||
|
||||
|
||||
glEnable(GL_DEPTH_TEST)
|
||||
|
||||
# Create and Compile a shader
|
||||
# but fail with a meaningful message if something goes wrong
|
||||
|
||||
def createAndCompileShader(type,source):
|
||||
shader=glCreateShader(type)
|
||||
glShaderSource(shader,source)
|
||||
glCompileShader(shader)
|
||||
|
||||
# get "compile status" - glCompileShader will not fail with
|
||||
# an exception in case of syntax errors
|
||||
|
||||
result=glGetShaderiv(shader,GL_COMPILE_STATUS)
|
||||
|
||||
if (result!=1): # shader didn't compile
|
||||
raise Exception("Couldn't compile shader\nShader compilation Log:\n"+glGetShaderInfoLog(shader))
|
||||
return shader
|
||||
|
||||
# Create and Compile fragment and vertex shaders
|
||||
# Transfer data from fragment to vertex shader
|
||||
|
||||
vertex_shader=createAndCompileShader(GL_VERTEX_SHADER,"""
|
||||
varying vec3 v;
|
||||
varying vec3 N;
|
||||
|
||||
void main(void)
|
||||
{
|
||||
|
||||
v = gl_ModelViewMatrix * gl_Vertex;
|
||||
N = gl_NormalMatrix * gl_Normal;
|
||||
|
||||
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
|
||||
|
||||
}
|
||||
""");
|
||||
|
||||
fragment_shader=createAndCompileShader(GL_FRAGMENT_SHADER,"""
|
||||
varying vec3 N;
|
||||
varying vec3 v;
|
||||
|
||||
void main(void)
|
||||
{
|
||||
vec3 L = gl_LightSource[0].position.xyz-v;
|
||||
|
||||
// "Lambert's law"? (see notes)
|
||||
// Rather: faces will appear dimmer when struck in an acute angle
|
||||
// distance attenuation
|
||||
|
||||
float Idiff = max(dot(normalize(L),N),0.0)*pow(length(L),-2.0);
|
||||
|
||||
gl_FragColor = vec4(0.5,0,0.5,1.0)+ // purple
|
||||
vec4(1.0,1.0,1.0,1.0)*Idiff; // diffuse reflection
|
||||
}
|
||||
""");
|
||||
|
||||
# build shader program
|
||||
|
||||
program=glCreateProgram()
|
||||
glAttachShader(program,vertex_shader)
|
||||
glAttachShader(program,fragment_shader)
|
||||
glLinkProgram(program)
|
||||
|
||||
# try to activate/enable shader program
|
||||
# handle errors wisely
|
||||
|
||||
try:
|
||||
glUseProgram(program)
|
||||
except OpenGL.error.GLError:
|
||||
print glGetProgramInfoLog(program)
|
||||
raise
|
||||
|
||||
done = False
|
||||
|
||||
t=0
|
||||
|
||||
# load a cube into a display list
|
||||
|
||||
glNewList(1,GL_COMPILE)
|
||||
|
||||
glBegin(GL_QUADS)
|
||||
|
||||
glColor3f(1,1,1)
|
||||
|
||||
glNormal3f(0,0,-1)
|
||||
glVertex3f( -1, -1, -1)
|
||||
glVertex3f( 1, -1, -1)
|
||||
glVertex3f( 1, 1, -1)
|
||||
glVertex3f( -1, 1, -1)
|
||||
|
||||
glNormal3f(0,0,1)
|
||||
glVertex3f( -1, -1, 1)
|
||||
glVertex3f( 1, -1, 1)
|
||||
glVertex3f( 1, 1, 1)
|
||||
glVertex3f( -1, 1, 1)
|
||||
|
||||
glNormal3f(0,-1,0)
|
||||
glVertex3f( -1, -1, -1)
|
||||
glVertex3f( 1, -1, -1)
|
||||
glVertex3f( 1, -1, 1)
|
||||
glVertex3f( -1, -1, 1)
|
||||
|
||||
glNormal3f(0,1,0)
|
||||
glVertex3f( -1, 1, -1)
|
||||
glVertex3f( 1, 1, -1)
|
||||
glVertex3f( 1, 1, 1)
|
||||
glVertex3f( -1, 1, 1)
|
||||
|
||||
glNormal3f(-1,0,0)
|
||||
glVertex3f( -1, -1, -1)
|
||||
glVertex3f( -1, 1, -1)
|
||||
glVertex3f( -1, 1, 1)
|
||||
glVertex3f( -1, -1, 1)
|
||||
|
||||
glNormal3f(1,0,0)
|
||||
glVertex3f( 1, -1, -1)
|
||||
glVertex3f( 1, 1, -1)
|
||||
glVertex3f( 1, 1, 1)
|
||||
glVertex3f( 1, -1, 1)
|
||||
|
||||
glEnd()
|
||||
glEndList()
|
||||
|
||||
while not done:
|
||||
|
||||
t=t+1
|
||||
|
||||
glMatrixMode(GL_PROJECTION)
|
||||
glLoadIdentity()
|
||||
gluPerspective(90,1,0.01,1000)
|
||||
gluLookAt(sin(t/260.0)*4,cos(t/260.0)*4,cos(t/687.0)*3,0,0,0,0,1,0)
|
||||
|
||||
glClearColor(0.0, 0.0, 0.0, 1.0)
|
||||
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
|
||||
|
||||
glMatrixMode(GL_MODELVIEW)
|
||||
|
||||
# calculate light source position
|
||||
|
||||
ld=[sin(t/16.0)*4.0,sin(t/20.0)*4.0,cos(t/16.0)*4.0]
|
||||
|
||||
# pass data to fragment shader
|
||||
|
||||
glLightfv(GL_LIGHT0,GL_POSITION,[ld[0],ld[1],ld[2]]);
|
||||
|
||||
# fallback
|
||||
|
||||
glColor3f(1,1,1)
|
||||
|
||||
glLoadIdentity()
|
||||
# render a pretty range of cubes
|
||||
|
||||
for i in range(-5,5):
|
||||
for j in range(-5,5):
|
||||
for k in range(-5,5):
|
||||
glPushMatrix()
|
||||
|
||||
glTranslate(i,j,k)
|
||||
glScale(0.1,0.1,0.1)
|
||||
glCallList(1)
|
||||
glPopMatrix()
|
||||
|
||||
pygame.display.flip()
|
||||
@@ -1,47 +0,0 @@
|
||||
#! /usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
import common2d, sys
|
||||
import OpenGL.GLUT as glut
|
||||
import OpenGL.GL as gl
|
||||
|
||||
_myProg = None
|
||||
|
||||
def displayFunc():
|
||||
global _myProg
|
||||
common2d.display(_myProg)
|
||||
glut.glutSwapBuffers()
|
||||
|
||||
def set_global_program(program):
|
||||
global _myProg
|
||||
_myProg = program
|
||||
|
||||
def reshape(width,height):
|
||||
gl.glViewport(0, 0, width, height)
|
||||
|
||||
def keyboard( key, x, y ):
|
||||
if key == '\033':
|
||||
sys.exit( )
|
||||
|
||||
if __name__=="__main__":
|
||||
# GLUT init
|
||||
# --------------------------------------
|
||||
glut.glutInit()
|
||||
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
|
||||
glut.glutCreateWindow('Hello world!')
|
||||
glut.glutReshapeWindow(640,480)
|
||||
glut.glutReshapeFunc(reshape)
|
||||
glut.glutDisplayFunc(displayFunc)
|
||||
glut.glutKeyboardFunc(keyboard)
|
||||
|
||||
program = common2d.init_shader_program()
|
||||
set_global_program(program)
|
||||
|
||||
# Make program the default program
|
||||
gl.glUseProgram(program)
|
||||
|
||||
# Enter mainloop
|
||||
# --------------------------------------
|
||||
glut.glutMainLoop()
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,4 +1,5 @@
|
||||
// copied from http://glslsandbox.com/e#47821.0
|
||||
|
||||
#ifdef GL_ES
|
||||
precision mediump float;
|
||||
#endif
|
||||
|
||||
@@ -1,70 +0,0 @@
|
||||
// copied from http://glslsandbox.com/e#47841.0
|
||||
|
||||
#ifdef GL_ES
|
||||
precision mediump float;
|
||||
#endif
|
||||
|
||||
uniform float u_time;
|
||||
uniform vec2 u_mouse;
|
||||
uniform vec2 u_resolution;
|
||||
uniform float u_tick;
|
||||
|
||||
float map(vec3 p)
|
||||
{
|
||||
const int MAX_ITER = 20;
|
||||
const float BAILOUT=2.0;
|
||||
float Power =2.;
|
||||
|
||||
vec3 v = p;
|
||||
vec3 c = vec3(cos(u_time*0.1), cos(u_time * 0.05234567), v.z);
|
||||
|
||||
float r=0.0;
|
||||
float d=1.0;
|
||||
for(int n=0; n<MAX_ITER; n++)
|
||||
{
|
||||
r = length(v);
|
||||
float zr = pow(r,Power);
|
||||
if(zr/r>BAILOUT) break; // improved
|
||||
|
||||
float theta = atan(v.z/length(v.xy)*tan(u_mouse.x*1.57))*tan(u_mouse.y*2.);
|
||||
float phi = atan(v.y, v.x);
|
||||
d = pow(r,Power-1.0)*Power*d+1.;
|
||||
|
||||
//theta = theta*2.;
|
||||
phi = phi*Power;
|
||||
v = (vec3(cos(theta)*cos(phi), sin(phi)*cos(theta), sin(theta))*zr)+c;
|
||||
}
|
||||
return 0.5*log(r)*r/d;
|
||||
}
|
||||
|
||||
|
||||
void main( void )
|
||||
{
|
||||
vec2 pos = (gl_FragCoord.xy*2.0 - u_resolution.xy) / u_resolution.y;
|
||||
vec3 camPos = vec3(1, 1, 1.5);
|
||||
vec3 camTarget = vec3(0.0, 0.0, 0.0);
|
||||
|
||||
vec3 camDir = normalize(camTarget-camPos);
|
||||
vec3 camUp = normalize(vec3(0.0, 1.0, 0.0));
|
||||
vec3 camSide = cross(camDir, camUp);
|
||||
float focus = 1.8;
|
||||
|
||||
vec3 rayDir = normalize(camSide*pos.x + camUp*pos.y + camDir*focus);
|
||||
vec3 ray = camPos;
|
||||
float m = 0.0;
|
||||
float d = 0.0, total_d = 0.0;
|
||||
const int MAX_MARCH = 150;
|
||||
const float MAX_DISTANCE = 10.0;
|
||||
for(int i=0; i<MAX_MARCH; ++i) {
|
||||
d = map(ray);
|
||||
total_d += d*1.11;
|
||||
ray += rayDir * d;
|
||||
m += 1.0;
|
||||
if(d<0.0002) { break; }
|
||||
if(total_d>MAX_DISTANCE) { total_d=MAX_DISTANCE; break; }
|
||||
}
|
||||
|
||||
float c = (total_d)*0.0001;
|
||||
vec3 result = vec3( vec3(0.8, 0.23, 0.1)*m*0.02 );
|
||||
gl_FragColor = vec4(result, 1);
|
||||
}
|
||||
85
shader_experiments/osc_example.py
Normal file
85
shader_experiments/osc_example.py
Normal file
@@ -0,0 +1,85 @@
|
||||
from tkinter import *
|
||||
from pythonosc import osc_message_builder
|
||||
from pythonosc import udp_client
|
||||
from pythonosc import dispatcher
|
||||
from pythonosc import osc_server
|
||||
import argparse
|
||||
import threading
|
||||
print('starting osc_example')
|
||||
|
||||
root = Tk()
|
||||
|
||||
def key(event):
|
||||
print("key pressed is {}".format(event.char))
|
||||
|
||||
if event.char == 'q':
|
||||
print('quiting program')
|
||||
root.destroy()
|
||||
elif event.char == 'a':
|
||||
print('loading video')
|
||||
send_osc_message("/player/a/load", "/home/pi/Videos/internal_storage/480-from-adobe.mp4")
|
||||
elif event.char == 's':
|
||||
print('playing video')
|
||||
send_osc_message("/player/a/play", True)
|
||||
elif event.char == 'd':
|
||||
print('pausing video')
|
||||
send_osc_message("/player/a/play", False)
|
||||
elif event.char == 'f':
|
||||
print('making video partly transparent')
|
||||
send_osc_message("/player/a/alpha", 200)
|
||||
elif event.char == 'g':
|
||||
print('quiting video')
|
||||
send_osc_message("/player/a/quit", True)
|
||||
elif event.char == 'h':
|
||||
print('seeking video')
|
||||
send_osc_message("/player/a/position", 0.5)
|
||||
elif event.char == 'j':
|
||||
print('requesting video position')
|
||||
send_osc_message("/player/a/get_position", True)
|
||||
|
||||
|
||||
def send_osc_message(address, value):
|
||||
client.send_message(address, value)
|
||||
|
||||
def set_position(unused_addr, args, player_name):
|
||||
print("the position of the player {} is {}".format(args, player_name))
|
||||
|
||||
def set_status(unused_addr, args, player_name):
|
||||
print("the status of the player {} is {}".format(args, player_name))
|
||||
|
||||
### setting up the client
|
||||
client_parser = argparse.ArgumentParser()
|
||||
client_parser.add_argument("--ip", default="127.0.0.1", help="the ip")
|
||||
client_parser.add_argument("--port", type=int, default=8000, help="the port")
|
||||
|
||||
client_args = client_parser.parse_args()
|
||||
|
||||
client = udp_client.SimpleUDPClient(client_args.ip, client_args.port)
|
||||
|
||||
### setting up the server
|
||||
server_parser = argparse.ArgumentParser()
|
||||
server_parser.add_argument("--ip", default="127.0.0.1", help="the ip")
|
||||
server_parser.add_argument("--port", type=int, default=7000, help="the port")
|
||||
|
||||
server_args = server_parser.parse_args()
|
||||
|
||||
dispatcher = dispatcher.Dispatcher()
|
||||
dispatcher.map("/player/a/position", set_position, "a")
|
||||
dispatcher.map("/player/b/position", set_position, "b")
|
||||
dispatcher.map("/player/c/position", set_position, "c")
|
||||
dispatcher.map("/player/a/status", set_status, "a")
|
||||
dispatcher.map("/player/b/status", set_status, "b")
|
||||
dispatcher.map("/player/c/status", set_status, "c")
|
||||
|
||||
server = osc_server.ThreadingOSCUDPServer((server_args.ip, server_args.port), dispatcher)
|
||||
server_thread = threading.Thread(target=server.serve_forever)
|
||||
server_thread.start()
|
||||
### setting up tk etc
|
||||
frame = Frame(root, width=100, height=100)
|
||||
frame.bind("<KeyPress>", key)
|
||||
frame.pack()
|
||||
|
||||
frame.focus_set()
|
||||
root.mainloop()
|
||||
|
||||
|
||||
@@ -1,36 +0,0 @@
|
||||
// Created by inigo quilez - iq/2013
|
||||
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
|
||||
|
||||
uniform vec3 u_Resolution; // viewport resolution (in pixels)
|
||||
uniform float u_Time; // shader playback time (in seconds)
|
||||
uniform float u_TimeDelta; // render time (in seconds)
|
||||
uniform int u_Frame; // shader playback frame
|
||||
uniform float u_ChannelTime[4];
|
||||
|
||||
void mainImage( out vec4 fragColor, in vec2 fragCoord )
|
||||
{
|
||||
vec2 q = fragCoord.xy / u_Resolution.xy;
|
||||
vec2 uv = 0.5 + (q-0.5)*(0.9 + 0.1*sin(0.2*u_Time));
|
||||
|
||||
vec3 oricol = texture( u_Channel0, vec2(q.x,1.0-q.y) ).xyz;
|
||||
vec3 col;
|
||||
|
||||
col.r = texture(u_Channel0,vec2(uv.x+0.003,-uv.y)).x;
|
||||
col.g = texture(u_Channel0,vec2(uv.x+0.000,-uv.y)).y;
|
||||
col.b = texture(u_Channel0,vec2(uv.x-0.003,-uv.y)).z;
|
||||
|
||||
col = clamp(col*0.5+0.5*col*col*1.2,0.0,1.0);
|
||||
|
||||
col *= 0.5 + 0.5*16.0*uv.x*uv.y*(1.0-uv.x)*(1.0-uv.y);
|
||||
|
||||
col *= vec3(0.95,1.05,0.95);
|
||||
|
||||
col *= 0.9+0.1*sin(10.0*u_Time+uv.y*1000.0);
|
||||
|
||||
col *= 0.99+0.01*sin(110.0*u_Time);
|
||||
|
||||
float comp = smoothstep( 0.2, 0.7, sin(u_Time) );
|
||||
col = mix( col, oricol, clamp(-2.0+2.0*q.x+3.0*comp,0.0,1.0) );
|
||||
|
||||
fragColor = vec4(col,1.0);
|
||||
}
|
||||
@@ -1,157 +0,0 @@
|
||||
# PyQt4 imports
|
||||
from PyQt4 import QtGui, QtCore, QtOpenGL
|
||||
from PyQt4.QtOpenGL import QGLWidget
|
||||
# PyOpenGL imports
|
||||
import OpenGL.GL as gl
|
||||
import OpenGL.arrays.vbo as glvbo
|
||||
|
||||
# Window creation function.
|
||||
def create_window(window_class):
|
||||
"""Create a Qt window in Python, or interactively in IPython with Qt GUI
|
||||
event loop integration:
|
||||
# in ~/.ipython/ipython_config.py
|
||||
c.TerminalIPythonApp.gui = 'qt'
|
||||
c.TerminalIPythonApp.pylab = 'qt'
|
||||
See also:
|
||||
http://ipython.org/ipython-doc/dev/interactive/qtconsole.html#qt-and-the-qtconsole
|
||||
"""
|
||||
app_created = False
|
||||
app = QtCore.QCoreApplication.instance()
|
||||
if app is None:
|
||||
app = QtGui.QApplication(sys.argv)
|
||||
app_created = True
|
||||
app.references = set()
|
||||
window = window_class()
|
||||
app.references.add(window)
|
||||
window.show()
|
||||
if app_created:
|
||||
app.exec_()
|
||||
return window
|
||||
|
||||
def compile_vertex_shader(source):
|
||||
"""Compile a vertex shader from source."""
|
||||
vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
|
||||
gl.glShaderSource(vertex_shader, source)
|
||||
gl.glCompileShader(vertex_shader)
|
||||
# check compilation error
|
||||
result = gl.glGetShaderiv(vertex_shader, gl.GL_COMPILE_STATUS)
|
||||
if not(result):
|
||||
raise RuntimeError(gl.glGetShaderInfoLog(vertex_shader))
|
||||
return vertex_shader
|
||||
|
||||
def compile_fragment_shader(source):
|
||||
"""Compile a fragment shader from source."""
|
||||
fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
|
||||
gl.glShaderSource(fragment_shader, source)
|
||||
gl.glCompileShader(fragment_shader)
|
||||
# check compilation error
|
||||
result = gl.glGetShaderiv(fragment_shader, gl.GL_COMPILE_STATUS)
|
||||
if not(result):
|
||||
raise RuntimeError(gl.glGetShaderInfoLog(fragment_shader))
|
||||
return fragment_shader
|
||||
|
||||
def link_shader_program(vertex_shader, fragment_shader):
|
||||
"""Create a shader program with from compiled shaders."""
|
||||
program = gl.glCreateProgram()
|
||||
gl.glAttachShader(program, vertex_shader)
|
||||
gl.glAttachShader(program, fragment_shader)
|
||||
gl.glLinkProgram(program)
|
||||
# check linking error
|
||||
result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
|
||||
if not(result):
|
||||
raise RuntimeError(gl.glGetProgramInfoLog(program))
|
||||
return program
|
||||
|
||||
# Vertex shader
|
||||
VS = """
|
||||
#version 330
|
||||
// Attribute variable that contains coordinates of the vertices.
|
||||
layout(location = 0) in vec2 position;
|
||||
|
||||
// Main function, which needs to set `gl_Position`.
|
||||
void main()
|
||||
{
|
||||
// The final position is transformed from a null signal to a sinewave here.
|
||||
// We pass the position to gl_Position, by converting it into
|
||||
// a 4D vector. The last coordinate should be 0 when rendering 2D figures.
|
||||
gl_Position = vec4(position.x, .2 * sin(20 * position.x), 0., 1.);
|
||||
}
|
||||
"""
|
||||
|
||||
# Fragment shader
|
||||
FS = """
|
||||
#version 330
|
||||
// Output variable of the fragment shader, which is a 4D vector containing the
|
||||
// RGBA components of the pixel color.
|
||||
out vec4 out_color;
|
||||
|
||||
// Main fragment shader function.
|
||||
void main()
|
||||
{
|
||||
// We simply set the pixel color to yellow.
|
||||
out_color = vec4(1., 1., 0., 1.);
|
||||
}
|
||||
"""
|
||||
|
||||
class GLPlotWidget(QGLWidget):
|
||||
# default window size
|
||||
width, height = 600, 600
|
||||
|
||||
def initializeGL(self):
|
||||
"""Initialize OpenGL, VBOs, upload data on the GPU, etc."""
|
||||
# background color
|
||||
gl.glClearColor(0, 0, 0, 0)
|
||||
# create a Vertex Buffer Object with the specified data
|
||||
self.vbo = glvbo.VBO(self.data)
|
||||
# compile the vertex shader
|
||||
vs = compile_vertex_shader(VS)
|
||||
# compile the fragment shader
|
||||
fs = compile_fragment_shader(FS)
|
||||
# compile the vertex shader
|
||||
self.shaders_program = link_shader_program(vs, fs)
|
||||
|
||||
def paintGL(self):
|
||||
"""Paint the scene."""
|
||||
# clear the buffer
|
||||
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
|
||||
# bind the VBO
|
||||
self.vbo.bind()
|
||||
# tell OpenGL that the VBO contains an array of vertices
|
||||
# prepare the shader
|
||||
gl.glEnableVertexAttribArray(0)
|
||||
# these vertices contain 2 single precision coordinates
|
||||
gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
|
||||
gl.glUseProgram(self.shaders_program)
|
||||
# draw "count" points from the VBO
|
||||
gl.glDrawArrays(gl.GL_LINE_STRIP, 0, len(self.data))
|
||||
|
||||
def resizeGL(self, width, height):
|
||||
"""Called upon window resizing: reinitialize the viewport."""
|
||||
# update the window size
|
||||
self.width, self.height = width, height
|
||||
# paint within the whole window
|
||||
gl.glViewport(0, 0, width, height)
|
||||
|
||||
if __name__ == '__main__':
|
||||
# import numpy for generating random data points
|
||||
import sys
|
||||
import numpy as np
|
||||
|
||||
# null signal
|
||||
data = np.zeros((10000, 2), dtype=np.float32)
|
||||
data[:,0] = np.linspace(-1., 1., len(data))
|
||||
|
||||
# define a Qt window with an OpenGL widget inside it
|
||||
class TestWindow(QtGui.QMainWindow):
|
||||
def __init__(self):
|
||||
super(TestWindow, self).__init__()
|
||||
# initialize the GL widget
|
||||
self.widget = GLPlotWidget()
|
||||
self.widget.data = data
|
||||
# put the window at the screen position (100, 100)
|
||||
self.setGeometry(100, 100, self.widget.width, self.widget.height)
|
||||
self.setCentralWidget(self.widget)
|
||||
self.show()
|
||||
|
||||
# show the window
|
||||
win = create_window(TestWindow)
|
||||
@@ -1,51 +0,0 @@
|
||||
BaseContext = testingcontext.getInteractive()
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.arrays import vbo
|
||||
from OpenGL.GL import shaders
|
||||
|
||||
class TextContext( BaseContext ):
|
||||
""" Creates a simple vertex shader ... """
|
||||
|
||||
def Oninit(self):
|
||||
VERTEX_SHADER = shaders.compileShader("""#version 120
|
||||
void main() {
|
||||
gl_position = gl_ModeViewProjectionMatrix * gl_Vertex;
|
||||
}""", GL_VERTEX_SHADER)
|
||||
|
||||
FRAGMENT_SHADER = shaders.compileShader("""#version 120
|
||||
void main() {
|
||||
gl_FragColor = vect4(0, 1, 0, 1 );
|
||||
}""", GL_FRAMENT_SHADER)
|
||||
|
||||
self.shader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)
|
||||
|
||||
self.vbo = vbo.VBO(
|
||||
array( [
|
||||
[ 0, 1, 0 ],
|
||||
[ -1, -1, 0 ],
|
||||
[ 1, -1, 0 ],
|
||||
[ 2, -1, 0 ],
|
||||
[ 4, -1, 0 ],
|
||||
[ 4, 1, 0 ],
|
||||
[ 2, -1, 0 ],
|
||||
[ 4, 1, 0 ],
|
||||
[ 2, 1, 0 ],
|
||||
], 'f')
|
||||
)
|
||||
|
||||
def Render(self, mode):
|
||||
""""Renders the geometry for the scene"""
|
||||
shaders.glUseProgram(self.shader)
|
||||
try:
|
||||
self.vbo.bind()
|
||||
try:
|
||||
glEnableClientState(GL_VERTEX_ARRAY)
|
||||
glVertexPointerf(self.vbo)
|
||||
glDrawArrays(GL_TRIANGLES,0,9)
|
||||
finally:
|
||||
self.vbo.unbind()
|
||||
glDisableClientState(GL_VERTEX_ARRAY)
|
||||
finally:
|
||||
shaders.glUseProgram(0)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user