opengl
ओजीएल दृश्य और प्रक्षेपण
खोज…
परिचय
मॉडल मैट्रिक्स के बारे में, मैट्रिक्स देखें, ऑर्थोग्राफिक- और परिप्रेक्ष्य प्रक्षेपण
OGL 4.0 GLSL 400 में एक कैमरा लागू करें
यदि हम एक दृश्य को देखना चाहते हैं जैसे कि हमने इसे कैमरे से देखा था, तो हमें पहले कुछ चीजों को परिभाषित करना होगा:
- जिस स्थिति से दृश्य देखा जाता है, वह स्थिति आंख की
pos। - जिस बिंदु को हम दृश्य (
target) में देखते हैं। जिस दिशा में हम देखते हैं, उसे परिभाषित करना भी आम है। तकनीकी रूप से हमें दृष्टि की एक पंक्ति की आवश्यकता है। अंतरिक्ष में एक सीधा गणितीय रूप से या तो 2 अंक या एक बिंदु और एक वेक्टर द्वारा परिभाषित किया गया है। परिभाषा के पहले भाग आँख की स्थिति है और 2 या तो हैtargetया दृष्टि वेक्टर की लाइनlos। - दिशा ऊपर की ओर
up। - देखने का क्षेत्र '
fov_y। इसका अर्थ है दो सीधी रेखाओं के बीच का कोण, आंख की स्थिति से शुरू होकर सबसे बाएं बिंदु और सबसे दाहिने बिंदु पर समाप्त होता है, जिसे एक साथ देखा जा सकता है। - व्यूपोर्ट के बड़े और पहलू अनुपात को हम अपनी छवि
vp - के पास विमान
nearहै और अब तक विमानfar। निकट विमान आँख की स्थिति से विमान की दूरी है जहाँ से वस्तुएँ हमें दिखाई देती हैं। दूर तल आँख की स्थिति से उस तल तक की दूरी है जिस तक दृश्य की वस्तुएँ हमें दिखाई देती हैं। पास के विमान और दूर के विमान की क्या जरूरत है, इसका स्पष्टीकरण बाद में दिया जाएगा।
C ++ और पायथन में इस डेटा की परिभाषा इस तरह दिख सकती है:
सी ++
using TVec3 = std::array<float,3>;
struct Camera
{
TVec3 pos {0.0, -8.0, 0.0};
TVec3 target {0.0, 0.0, 0.0};
TVec3 up {0.0, 0.0, 1.0};
float fov_y {90.0};
TSize vp {800, 600};
float near {0.5};
float far {100.0};
};
अजगर
class Camera:
def __init__(self):
self.pos = (0, -8, 0)
self.target = (0, 0, 0)
self.up = (0, 0, 1)
self.fov_y = 90
self.vp = (800, 600)
self.near = 0.5
self.far = 100.0
यह सब जानकारी एक दृश्य को खींचते समय, एक प्रक्षेपण मैट्रिक्स और एक दृश्य मैट्रिक्स का आमतौर पर उपयोग किया जाता है। दृश्य में एक दृश्य के अलग-अलग हिस्सों को व्यवस्थित करने के लिए, मॉडल मैट्रिस का उपयोग किया जाता है। हालांकि, ये केवल पूर्णता के लिए यहां उल्लिखित हैं और यहां से निपटा नहीं जाएगा।
प्रोजेक्शन मैट्रिक्स: प्रोजेक्शन मैट्रिक्स दुनिया में 3 डी बिंदुओं से मैपिंग का वर्णन करता है, क्योंकि वे पिनहोल कैमरा से देखे जाते हैं, व्यूपोर्ट के 2 डी बिंदुओं तक।
मैट्रिक्स देखें: व्यू मैट्रिक्स आँख की स्थिति और दृश्य को देखने की दिशा को परिभाषित करता है।
मॉडल मैट्रिक्स: मॉडल मैट्रिक्स दृश्य में किसी वस्तु के स्थान और सापेक्ष आकार को परिभाषित करता है।
जब हमने डेटा संरचनाओं को संबंधित डेटा के साथ भर दिया है, तो हमें उन्हें उपयुक्त मेट्रिसेस में अनुवाद करना होगा। ओजीएल संगतता मोड में, इस के साथ किया जा सकता है gluLookAt और gluPerspective कार्यों कि वर्दी में बनाया गया सेट gl_ModelViewMatrix , gl_NormalMatrix , और gl_ModelViewProjectionMatrix । OGL 3.1 और GLSL #version 150 में निर्मित वर्दी को हटा दिया गया था, क्योंकि पूरे फिक्स्ड-फंक्शन मैट्रिक्स स्टैक को हटा दिया गया था। यदि हम GLSL संस्करण 330 या उससे अधिक के साथ OGL उच्च स्तरीय shader का उपयोग करना चाहते हैं, तो हमें अपने स्वयं के (स्वयं GLSL compatibility कीवर्ड के उपयोग के अलावा) मैट्रिक्स वर्दी को परिभाषित और निर्धारित करना होगा।
परिप्रेक्ष्य सेट करें - प्रोजेक्शन मैट्रिक्स
व्यूपोर्ट पर एक बिंदु दिखाई देता है जब यह मूल AABB (अक्ष संरेखित सीमा बॉक्स) अंक (-1.0, -1.0, -1.0) और (1.0, 1.0, 1.0) द्वारा परिभाषित होता है। इसे सामान्यीकृत उपकरण निर्देशांक (NDC) कहा जाता है। निर्देशांक (-1.0, -1.0, z) साथ एक बिंदु को व्यूपोर्ट के निचले बाएं कोने में चित्रित किया जाएगा और निर्देशांक (1.0, 1.0, z) साथ एक बिंदु को व्यूपोर्ट के ऊपरी दाएं कोने में चित्रित किया जाएगा। Z- समन्वय को अंतराल (-1.0, 1.0) से अंतराल (0.0, 1.0) में मैप किया जाता है और Z- बफर में लिखा जाता है।
दृश्य से हम सभी देख सकते हैं कि यह 4-पक्षीय पिरामिड के भीतर है। पिरामिड के शीर्ष पर आंख की स्थिति है । पिरामिड के 4 पक्ष दृश्य ( fov_y ) और पहलू अनुपात ( vp[0]/vp[1] ) के फाइल द्वारा परिभाषित किए गए हैं। प्रक्षेपण मैट्रिक्स को पिरामिड के अंदर से बिंदुओं (-1.0, -1.0, -1.0) और (1.0, 1.0, 1.0) द्वारा परिभाषित एनडीसी के बिंदुओं को मैप करना है। इस बिंदु पर हमारा पिरामिड अनंत है, इसका गहराई में कोई अंत नहीं है और हम अनंत अंतरिक्ष को परिमित करने के लिए मैप नहीं कर सकते हैं। इसके लिए हमें अब पास के विमान और दूर के विमान की आवश्यकता है , वे पिरामिड को ऊपर से काटकर और गहराई में पिरामिड को सीमित करके एक फ्रुम में बदल देते हैं। पास के प्लेन और दूर के प्लेन को इस तरह से चुनना होता है कि उनमें वह सब कुछ शामिल हो जो दृश्य से दिखाई दे।
एनडीसी के लिए एक हताशा के भीतर अंक से मानचित्रण शुद्ध गणित है और आम तौर पर हल किया जा सकता है। सूत्रों के विकास पर अक्सर चर्चा की गई और पूरे वेब पर बार-बार प्रकाशित किया गया। चूँकि आप एक स्टैक ओवरफ्लो डॉक्यूमेंटेशन में LaTeX फॉर्मूला नहीं डाल सकते हैं, इसलिए इसे यहाँ से हटा दिया जाता है और केवल पूरा C ++ और पायथन सोर्स कोड जोड़ा जाता है। ध्यान दें कि आंख निर्देशांक दाहिने हाथ के समन्वय प्रणाली में परिभाषित किए गए हैं, लेकिन NDC बाएं हाथ के समन्वय प्रणाली का उपयोग करता है। प्रक्षेपण मैट्रिक्स से की जाती है, दृश्य के क्षेत्र fov_y , पहलू अनुपात vp[0]/vp[1] , के पास विमान near है और अब तक विमान far ।
सी ++
using TVec4 = std::array< float, 4 >;
using TMat44 = std::array< TVec4, 4 >;
TMat44 Camera::Perspective( void )
{
float fn = far + near;
float f_n = far - near;
float r = (float)vp[0] / vp[1];
float t = 1.0f / tan( ToRad( fov_y ) / 2.0f );
return TMat44{
TVec4{ t / r, 0.0f, 0.0f, 0.0f },
TVec4{ 0.0f, t, 0.0f, 0.0f },
TVec4{ 0.0f, 0.0f, -fn / f_n, -1.0 },
TVec4{ 0.0f, 0.0f, -2.0f * far * near / f_n, 0.0f } };
}
अजगर
def Perspective(self):
fn, = self.far + self.near
f_n = self.far - self.near
r = self.vp[0] / self.vp[1]
t = 1 / math.tan( math.radians( self.fov_y ) / 2 )
return numpy.matrix( [
[ t/r, 0, 0, 0 ],
[ 0, t, 0, 0 ],
[ 0, 0, -fn/f_n, -1 ],
[ 0, 0, -2 * self.far * self.near / f_n, 0 ] ] )
दृश्य को देखें - मैट्रिक्स देखें
व्यूपोर्ट पर समन्वय प्रणाली में, Y- अक्ष ऊपर (0, 1, 0) को इंगित करता है और X अक्ष दाईं ओर (1, 0, 0) को इंगित करता है। इससे एक Z- अक्ष प्राप्त होता है जो व्यूपोर्ट से बाहर (0, 0, -1) = cross( X-axis, Y-axis ) को इंगित करता है।
दृश्य में, एक्स अक्ष पूर्व की ओर, उत्तर में वाई अक्ष, और शीर्ष पर जेड अक्ष को इंगित करता है।
एक्स व्यूपोर्ट की धुरी (1, 0, 0) दृश्य के Y- अक्ष से मेल खाता है (1, 0, 0) , वाई व्यूपोर्ट की धुरी (0, 1, 0 ) दृश्य के Z अक्ष से मेल खाता है (0, 0, 1) और व्यूपोर्ट का Z अक्ष (0, 0, 1 ) दृश्य के नकारात्मक Y अक्ष से मेल खाता है (0, -1, 0) ।
दृश्य के संदर्भ प्रणाली से प्रत्येक बिंदु और प्रत्येक वेक्टर को पहले व्यूपोर्ट निर्देशांक में परिवर्तित किया जाना चाहिए। यह स्केलर वैक्टर में कुछ स्वैपिंग और इनवर्टिंग ऑपरेशन द्वारा किया जा सकता है।
x y z
--------
1 0 0 | x' = x
0 0 1 | y' = z
0 -1 0 | z' = -y
सेटअप करने के लिए एक दृश्य के मैट्रिक्स स्थिति pos , लक्ष्य target और ऊपर वेक्टर up है, जैसा कि ऊपर वर्णित व्यूपोर्ट समन्वय प्रणाली में मैप किया। यह 2 अंक p और t और वेक्टर u , जैसा कि निम्नलिखित कोड स्निपेट में है। व्यू मैट्रिक्स का Z अक्ष दृष्टि की व्युत्क्रम रेखा है, जिसकी गणना p - t द्वारा की जाती है। Y अक्ष अप वेक्टर u । एक्स अक्ष की गणना वाई अक्ष और जेड अक्ष के क्रॉस उत्पाद द्वारा की जाती है। दृश्य मैट्रिक्स को orthonormalising के लिए, क्रॉस उत्पाद का दूसरी बार उपयोग किया जाता है, Z अक्ष से Y अक्ष की गणना करने के लिए और X अक्ष (निश्चित रूप से ग्राम-श्मिट orthogonalization बस के रूप में अच्छी तरह से काम करेगा)। अंत में, सभी 3 धुरों को सामान्य किया जाना चाहिए और आंख की pos को दृश्य मैट्रिक्स के मूल के रूप में सेट करना होगा।
नीचे दिया गया कोड एक मैट्रिक्स को परिभाषित करता है जो दृश्य पर एक नज़र की गणना करने के लिए आवश्यक चरणों को पूरी तरह से समझाया गया है:
- परिवर्तित मॉडल व्यूपोर्ट निर्देशांक में समन्वय करता है।
- देखने की दिशा की दिशा में घुमाएं।
- आंख की स्थिति के लिए आंदोलन
सी ++
template< typename T_VEC >
TVec3 Cross( T_VEC a, T_VEC b )
{
return { a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] };
}
template< typename T_A, typename T_B >
float Dot( T_A a, T_B b )
{
return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
}
template< typename T_VEC >
void Normalize( T_VEC & v )
{
float len = sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] ); v[0] /= len; v[1] /= len; v[2] /= len;
}
TMat44 Camera::LookAt( void )
{
TVec3 mz = { pos[0] - target[0], pos[1] - target[1], pos[2] - target[2] };
Normalize( mz );
TVec3 my = { up[0], up[1], up[2] };
TVec3 mx = Cross( my, mz );
Normalize( mx );
my = Cross( mz, mx );
TMat44 v{
TVec4{ mx[0], my[0], mz[0], 0.0f },
TVec4{ mx[1], my[1], mz[1], 0.0f },
TVec4{ mx[2], my[2], mz[2], 0.0f },
TVec4{ Dot(mx, pos), Dot(my, pos), Dot(TVec3{-mz[0], -mz[1], -mz[2]}, pos), 1.0f }
};
return v;
}
अजगर
def LookAt(self):
mz = Normalize( (self.pos[0]-self.target[0], self.pos[1]-self.target[1], self.pos[2]-self.target[2]) ) # inverse line of sight
mx = Normalize( Cross( self.up, mz ) )
my = Normalize( Cross( mz, mx ) )
tx = Dot( mx, self.pos )
ty = Dot( my, self.pos )
tz = Dot( (-mz[0], -mz[1], -mz[2]), self.pos )
return = numpy.matrix( [
[mx[0], my[0], mz[0], 0],
[mx[1], my[1], mz[1], 0],
[mx[2], my[2], mz[2], 0],
[tx, ty, tz, 1] ] )
अंत में मैट्रिफ़ को वर्दी में लिखा जाता है और मॉडल पदों को बदलने के लिए वर्टीकल शेडर में उपयोग किया जाता है।
वर्टेक्स शेडर
शीर्ष शेकर में, एक के बाद एक परिवर्तन किया जाता है।
- मॉडल मैट्रिक्स दृश्य में ऑब्जेक्ट (मेष) को अपनी जगह पर लाता है। (यह केवल पूर्णता के लिए सूचीबद्ध किया गया है और यहां दस्तावेज नहीं किया गया है क्योंकि इसका दृश्य के दृश्य से कोई लेना-देना नहीं है)
- दृश्य मैट्रिक्स उस दिशा को परिभाषित करता है जिससे दृश्य देखा जाता है। दृश्य मैट्रिक्स के साथ परिवर्तन दृश्य की वस्तुओं को घुमाता है ताकि उन्हें व्यूपोर्ट की समन्वय प्रणाली के संदर्भ में देखने की वांछित दिशा से देखा जाए।
- प्रोजेक्शन मैट्रिक्स एक समानांतर दृश्य से वस्तुओं को एक परिप्रेक्ष्य दृश्य में बदल देता है।
#version 400
layout (location = 0) in vec3 inPos;
layout (location = 1) in vec3 inCol;
out vec3 vertCol;
uniform mat4 u_projectionMat44;
uniform mat4 u_viewMat44;
uniform mat4 u_modelMat44;
void main()
{
vertCol = inCol;
vec4 modelPos = u_modelMat44 * vec4( inPos, 1.0 );
vec4 viewPos = u_viewMat44 * modelPos;
gl_Position = u_projectionMat44 * viewPos;
}
भगदड़ शैडर
पूर्णता की खातिर ही यहाँ खंडित छायाकार को सूचीबद्ध किया गया है। पहले काम हो गया था।
#version 400
in vec3 vertCol;
out vec4 fragColor;
void main()
{
fragColor = vec4( vertCol, 1.0 );
}
शेडर को संकलित और पसंद किए जाने के बाद, मैट्रिसेस एकसमान चरों तक बंध सकते हैं।
सी ++
int shaderProg = ;
Camera camera;
// ...
int prjMatLocation = glGetUniformLocation( shaderProg, "u_projectionMat44" );
int viewMatLocation = glGetUniformLocation( shaderProg, "u_viewMat44" );
glUniformMatrix4fv( prjMatLocation, 1, GL_FALSE, camera.Perspective().data()->data() );
glUniformMatrix4fv( viewMatLocation, 1, GL_FALSE, camera.LookAt().data()->data() );
अजगर
shaderProg =
camera = Camera()
# ...
prjMatLocation = glGetUniformLocation( shaderProg, b"u_projectionMat44" )
viewMatLocation = glGetUniformLocation( shaderProg, b"u_viewMat44" )
glUniformMatrix4fv( prjMatLocation, 1, GL_FALSE, camera.Perspective() )
glUniformMatrix4fv( viewMatLocation, 1, GL_FALSE, camera.LookAt() )
इसके अलावा, मैंने एक पायथन उदाहरण के पूरे कोड डंप को जोड़ा है (सी ++ उदाहरण जोड़ने के लिए दुर्भाग्य से 30000 वर्णों की सीमा को पार कर जाएगा)। इस उदाहरण में, कैमरा दीर्घवृत्त के चारों ओर दीर्घवृत्त के चारों ओर दीर्घवृत्त के केंद्र बिंदु पर जाता है। देखने की दिशा हमेशा टेट्राइडर को निर्देशित की जाती है।
अजगर
पायथन लिपि को चलाने के लिए NumPy को स्थापित करना होगा।
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import numpy
from time import time
import math
import sys
def Cross( a, b ): return ( a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0], 0.0 )
def Dot( a, b ): return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
def Normalize( v ):
len = math.sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] )
return (v[0] / len, v[1] / len, v[2] / len)
class Camera:
def __init__(self):
self.pos = (0, -8, 0)
self.target = (0, 0, 0)
self.up = (0, 0, 1)
self.fov_y = 90
self.vp = (800, 600)
self.near = 0.5
self.far = 100.0
def Perspective(self):
fn, f_n = self.far + self.near, self.far - self.near
r, t = self.vp[0] / self.vp[1], 1 / math.tan( math.radians( self.fov_y ) / 2 )
return numpy.matrix( [ [t/r,0,0,0], [0,t,0,0], [0,0,-fn/f_n,-1], [0,0,-2*self.far*self.near/f_n,0] ] )
def LookAt(self):
mz = Normalize( (self.pos[0]-self.target[0], self.pos[1]-self.target[1], self.pos[2]-self.target[2]) ) # inverse line of sight
mx = Normalize( Cross( self.up, mz ) )
my = Normalize( Cross( mz, mx ) )
tx = Dot( mx, self.pos )
ty = Dot( my, self.pos )
tz = Dot( (-mz[0], -mz[1], -mz[2]), self.pos )
return = numpy.matrix( [ [mx[0], my[0], mz[0], 0], [mx[1], my[1], mz[1], 0], [mx[2], my[2], mz[2], 0], [tx, ty, tz, 1] ] )
# shader program object
class ShaderProgram:
def __init__( self, shaderList, uniformNames ):
shaderObjs = []
for sh_info in shaderList: shaderObjs.append( self.CompileShader(sh_info[0], sh_info[1] ) )
self.LinkProgram( shaderObjs )
self.__unifomLocation = {}
for name in uniformNames:
self.__unifomLocation[name] = glGetUniformLocation( self.__prog, name )
print( "uniform %-30s at loaction %d" % (name, self.__unifomLocation[name]) )
def Use(self):
glUseProgram( self.__prog )
def SetUniformMat44( self, name, mat ):
glUniformMatrix4fv( self.__unifomLocation[name], 1, GL_FALSE, mat )
# read shader program and compile shader
def CompileShader(self, sourceFileName, shaderStage):
with open( sourceFileName, 'r' ) as sourceFile:
sourceCode = sourceFile.read()
nameMap = { GL_VERTEX_SHADER: 'vertex', GL_FRAGMENT_SHADER: 'fragment' }
print( '\n%s shader code:' % nameMap.get( shaderStage, '' ) )
print( sourceCode )
shaderObj = glCreateShader( shaderStage )
glShaderSource( shaderObj, sourceCode )
glCompileShader( shaderObj )
result = glGetShaderiv( shaderObj, GL_COMPILE_STATUS )
if not (result):
print( glGetShaderInfoLog( shaderObj ) )
sys.exit()
return shaderObj
# linke shader objects to shader program
def LinkProgram(self, shaderObjs):
self.__prog = glCreateProgram()
for shObj in shaderObjs: glAttachShader( self.__prog, shObj )
glLinkProgram( self.__prog )
result = glGetProgramiv( self.__prog, GL_LINK_STATUS )
if not ( result ):
print( 'link error:' )
print( glGetProgramInfoLog( self.__prog ) )
sys.exit()
# vertex array object
class VAObject:
def __init__( self, dataArrays, tetIndices ):
self.__obj = glGenVertexArrays( 1 )
self.__noOfIndices = len( tetIndices )
self.__indexArr = numpy.array( tetIndices, dtype='uint' )
noOfBuffers = len( dataArrays )
buffers = glGenBuffers( noOfBuffers )
glBindVertexArray( self.__obj )
for i_buffer in range( 0, noOfBuffers ):
vertexSize, dataArr = dataArrays[i_buffer]
glBindBuffer( GL_ARRAY_BUFFER, buffers[i_buffer] )
glBufferData( GL_ARRAY_BUFFER, numpy.array( dataArr, dtype='float32' ), GL_STATIC_DRAW )
glEnableVertexAttribArray( i_buffer )
glVertexAttribPointer( i_buffer, vertexSize, GL_FLOAT, GL_FALSE, 0, None )
def Draw(self):
glBindVertexArray( self.__obj )
glDrawElements( GL_TRIANGLES, self.__noOfIndices, GL_UNSIGNED_INT, self.__indexArr )
# glut window
class Window:
def __init__( self, cx, cy ):
self.__vpsize = ( cx, cy )
glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH )
glutInitWindowPosition( 0, 0 )
glutInitWindowSize( self.__vpsize[0], self.__vpsize[1] )
self.__id = glutCreateWindow( b'OGL window' )
glutDisplayFunc( self.OnDraw )
glutIdleFunc( self.OnDraw )
def Run( self ):
self.__startTime = time()
glutMainLoop()
# draw event
def OnDraw(self):
self.__vpsize = ( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) )
currentTime = time()
# set up camera
camera = Camera()
camera.vp = self.__vpsize
camera.pos = self.EllipticalPosition( 7, 4, self.CalcAng( currentTime, 10 ) )
# set up attributes and shader program
glEnable( GL_DEPTH_TEST )
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT )
prog.Use()
prog.SetUniformMat44( b"u_projectionMat44", camera.Perspective() )
prog.SetUniformMat44( b"u_viewMat44", camera.LookAt() )
# draw object
modelMat = numpy.matrix(numpy.identity(4), copy=False, dtype='float32')
prog.SetUniformMat44( b"u_modelMat44", modelMat )
tetVAO.Draw()
glutSwapBuffers()
def Fract( self, val ): return val - math.trunc(val)
def CalcAng( self, currentTime, intervall ): return self.Fract( (currentTime - self.__startTime) / intervall ) * 2.0 * math.pi
def CalcMove( self, currentTime, intervall, range ):
pos = self.Fract( (currentTime - self.__startTime) / intervall ) * 2.0
pos = pos if pos < 1.0 else (2.0-pos)
return range[0] + (range[1] - range[0]) * pos
def EllipticalPosition( self, a, b, angRag ):
a_b = a * a - b * b
ea = 0 if (a_b <= 0) else math.sqrt( a_b )
eb = 0 if (a_b >= 0) else math.sqrt( -a_b )
return ( a * math.sin( angRag ) - ea, b * math.cos( angRag ) - eb, 0 )
# initialize glut
glutInit()
# create window
wnd = Window( 800, 600 )
# define tetrahedron vertex array opject
sin120 = 0.8660254
tetVAO = VAObject(
[ (3, [ 0.0, 0.0, 1.0, 0.0, -sin120, -0.5, sin120 * sin120, 0.5 * sin120, -0.5, -sin120 * sin120, 0.5 * sin120, -0.5 ]),
(3, [ 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, ])
],
[ 0, 1, 2, 0, 2, 3, 0, 3, 1, 1, 3, 2 ]
)
# load, compile and link shader
prog = ShaderProgram(
[ ('python/ogl4camera/camera.vert', GL_VERTEX_SHADER),
('python/ogl4camera/camera.frag', GL_FRAGMENT_SHADER)
],
[b"u_projectionMat44", b"u_viewMat44", b"u_modelMat44"] )
# start main loop
wnd.Run()