func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shape.buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
gl.BufferData(gl.ARRAY_BUFFER, EncodeObject(cubeData), gl.STATIC_DRAW)
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.vertTexCoord = gl.GetAttribLocation(e.shader.program, "vertTexCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.model = gl.GetUniformLocation(e.shader.program, "model")
e.shape.texture, err = LoadTexture("gopher.png")
if err != nil {
panic(fmt.Sprintln("LoadTexture failed:", err))
}
e.started = time.Now()
}
func onStart() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
//创建一个WebGLBuffer对象，把它绑定到顶点缓冲上，并把顶点数据载入到顶点冲。
buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, lineData, gl.STATIC_DRAW)
/*opengl中三种变量
uniform变量是外部application程序传递给（vertex和fragment）shader的变量。因此它是application通过函数glUniform**（）函数赋值的。
在（vertex和fragment）shader程序内部，uniform变量就像是C语言里面的常量（const ），它不能被shader程序修改。（shader只能用，不能改）
attribute变量是只能在vertex shader中使用的变量。（它不能在fragment shader中声明attribute变量，也不能被fragment shader中使用）
一般用attribute变量来表示一些顶点的数据，如：顶点坐标，法线，纹理坐标，顶点颜色等。
在application中，一般用函数glBindAttribLocation（）来绑定每个attribute变量的位置，然后用函数glVertexAttribPointer（）为每个attribute变量赋值。
varying变量是vertex和fragment shader之间做数据传递用的。一般vertex shader修改varying变量的值，然后fragment shader使用该varying变量的值。
因此varying变量在vertex和fragment shader二者之间的声明必须是一致的。application不能使用此变量。
*/
position = gl.GetAttribLocation(program, "position") //获取位置对象(索引)
color = gl.GetUniformLocation(program, "color") // 获取颜色对象(索引)
scan = gl.GetUniformLocation(program, "scan") // 获取偏移对象(索引)
// fmt.Println(position.String(),color.String(),offset.String())//Attrib(0) Uniform(1) Uniform(0)
// TODO(crawshaw): the debug package needs to put GL state init here
// Can this be an event.Register call now??
}
func start() {
var err error
glimage.program, err = CreateProgram(vertexShader, fragmentShader)
if err != nil {
panic(err)
}
glimage.quadXY = gl.CreateBuffer()
glimage.quadUV = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadXY)
gl.BufferData(gl.ARRAY_BUFFER, quadXYCoords, gl.STATIC_DRAW)
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadUV)
gl.BufferData(gl.ARRAY_BUFFER, quadUVCoords, gl.STATIC_DRAW)
glimage.pos = gl.GetAttribLocation(glimage.program, "pos")
glimage.mvp = gl.GetUniformLocation(glimage.program, "mvp")
glimage.uvp = gl.GetUniformLocation(glimage.program, "uvp")
glimage.inUV = gl.GetAttribLocation(glimage.program, "inUV")
glimage.textureSample = gl.GetUniformLocation(glimage.program, "textureSample")
texmap.Lock()
defer texmap.Unlock()
for key, tex := range texmap.texs {
texmap.init(key)
tex.needsUpload = true
}
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shader.models, err = wavefront.Read("gopher.obj")
check(err)
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.modelx = gl.GetUniformLocation(e.shader.program, "modelx")
e.shader.modely = gl.GetUniformLocation(e.shader.program, "modely")
e.shader.color = gl.GetUniformLocation(e.shader.program, "color")
for _, model := range e.shader.models {
for _, group := range model.Groups {
data := f32.Bytes(binary.LittleEndian, group.Vertexes...)
color := group.Material.Ambient
vertexCount := len(data)
databuf := gl.CreateBuffer()
e.shape.bufs = append(e.shape.bufs, Buf{vertexCount, databuf, color})
gl.BindBuffer(gl.ARRAY_BUFFER, databuf)
gl.BufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)
}
}
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shape.buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
gl.BufferData(gl.ARRAY_BUFFER, cubeData, gl.STATIC_DRAW)
fmt.Println(len(cubeData))
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.modelx = gl.GetUniformLocation(e.shader.program, "modelx")
e.shader.modely = gl.GetUniformLocation(e.shader.program, "modely")
e.shader.color = gl.GetAttribLocation(e.shader.program, "color")
e.shape.colorbuf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.colorbuf)
gl.BufferData(gl.ARRAY_BUFFER, colorData, gl.STATIC_DRAW)
gl.VertexAttribPointer(e.shader.color, colorsPerVertex, gl.FLOAT, false, 4, 0) //更新color值
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
e.started = time.Now()
}
func onStart() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, rectData, gl.STATIC_DRAW)
position = gl.GetAttribLocation(program, "position")
color = gl.GetUniformLocation(program, "color")
offset = gl.GetUniformLocation(program, "offset")
}
func initGL() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
buf = gl.GenBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, gl.STATIC_DRAW, triangleData)
position = gl.GetAttribLocation(program, "position")
color = gl.GetUniformLocation(program, "color")
offset = gl.GetUniformLocation(program, "offset")
touchLoc = geom.Point{geom.Width / 2, geom.Height / 2}
}
func (shader *shader) Uniform(name string) gl.Uniform {
v, ok := shader.uniforms[name]
if !ok {
v = gl.GetUniformLocation(shader.program, name)
shader.uniforms[name] = v
}
return v
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
fmt.Println(len(cubeData))
e.shape.buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
gl.BufferData(gl.ARRAY_BUFFER, cubeData, gl.STATIC_DRAW)
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.modelx = gl.GetUniformLocation(e.shader.program, "modelx")
e.shader.modely = gl.GetUniformLocation(e.shader.program, "modely")
}
func onStart() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, triangleData, gl.STATIC_DRAW)
position = gl.GetAttribLocation(program, "position")
color = gl.GetUniformLocation(program, "color")
offset = gl.GetUniformLocation(program, "offset")
// TODO(crawshaw): the debug package needs to put GL state init here
// Can this be an app.RegisterFilter call now??
}
func onPaint(sz size.Event) {
gl.ClearColor(rgb(156), rgb(39), rgb(176), 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
var rotationMatrix = []float32{
f32.Cos(-alpha), -f32.Sin(-alpha), 0.0,
f32.Sin(-alpha), f32.Cos(-alpha), 0.0,
0.0, 0.0, 1.0,
}
gl.UseProgram(program)
// setting color
gl.Uniform4f(color, rgb(255), rgb(255), rgb(255), 1)
gl.UniformMatrix3fv(matrixId, rotationMatrix)
gl.Uniform1f(resolutionId, resIndex)
gl.BindBuffer(gl.ARRAY_BUFFER, swasBuffer)
gl.EnableVertexAttribArray(position)
gl.VertexAttribPointer(position, 3, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.LINES, 0, 16)
gl.DisableVertexAttribArray(position)
gl.UseProgram(texProgram)
// setting color
gl.Uniform4f(color2, rgb(130), rgb(50), rgb(80), 1)
gl.Uniform1f(resolutionId2, resIndex)
gl.UniformMatrix3fv(matrixId2, rotationMatrix)
gl.BindBuffer(gl.ARRAY_BUFFER, quadBuffer)
gl.EnableVertexAttribArray(position2)
gl.VertexAttribPointer(position2, 3, gl.FLOAT, false, 0, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, quadTexBuffer)
gl.EnableVertexAttribArray(textureCoords)
gl.VertexAttribPointer(textureCoords, 2, gl.FLOAT, false, 0, 0)
gl.Uniform1i(gl.GetUniformLocation(texProgram, "myTexture"), 0)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, textureId)
gl.DrawArrays(gl.TRIANGLES, 0, 6)
gl.DisableVertexAttribArray(position2)
gl.DisableVertexAttribArray(textureCoords)
if spin == true {
alpha += 0.1
}
if alpha >= 360 {
alpha = 0.0
}
}
func glInit() {
var err error
glimage.program, err = CreateProgram(vertexShader, fragmentShader)
if err != nil {
panic(err)
}
glimage.quadXY = gl.GenBuffer()
glimage.quadUV = gl.GenBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadXY)
gl.BufferData(gl.ARRAY_BUFFER, gl.STATIC_DRAW, quadXYCoords)
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadUV)
gl.BufferData(gl.ARRAY_BUFFER, gl.STATIC_DRAW, quadUVCoords)
glimage.pos = gl.GetAttribLocation(glimage.program, "pos")
glimage.mvp = gl.GetUniformLocation(glimage.program, "mvp")
glimage.uvp = gl.GetUniformLocation(glimage.program, "uvp")
glimage.inUV = gl.GetAttribLocation(glimage.program, "inUV")
glimage.textureSample = gl.GetUniformLocation(glimage.program, "textureSample")
}
func initKeys() {
var err error
program, err = glutil.CreateProgram(
`#version 100
uniform mat4 projection;
attribute vec3 position;
attribute float pointsize;
void main() {
gl_Position = projection * vec4(position, 1);
gl_PointSize = pointsize;
}`,
`#version 100
precision mediump float;
uniform vec4 color;
void main(void)
{
vec2 v = 2.0*gl_PointCoord.xy - vec2(1.0);
float r2 = dot(v, v);
gl_FragColor = mix(color, vec4(0), r2);
}`,
)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
gl.Enable(34370) // GL_PROGRAM_POINT_SIZE; apparently not necessary on Android
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.ONE, gl.ONE_MINUS_SRC_COLOR)
projection = gl.GetUniformLocation(program, "projection")
updateProjectionMatrix()
position = gl.GetAttribLocation(program, "position")
pointsize = gl.GetAttribLocation(program, "pointsize")
color = gl.GetUniformLocation(program, "color")
positionbuf = gl.CreateBuffer()
pointsizebuf = gl.CreateBuffer()
updateKeys(ratio{1, 1})
}
func (s *screenImpl) NewTexture(size image.Point) (screen.Texture, error) {
s.mu.Lock()
defer s.mu.Unlock()
if !gl.IsProgram(s.texture.program) {
p, err := compileProgram(textureVertexSrc, textureFragmentSrc)
if err != nil {
return nil, err
}
s.texture.program = p
s.texture.pos = gl.GetAttribLocation(p, "pos")
s.texture.mvp = gl.GetUniformLocation(p, "mvp")
s.texture.uvp = gl.GetUniformLocation(p, "uvp")
s.texture.inUV = gl.GetAttribLocation(p, "inUV")
s.texture.sample = gl.GetUniformLocation(p, "sample")
s.texture.quadXY = gl.CreateBuffer()
s.texture.quadUV = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, s.texture.quadXY)
gl.BufferData(gl.ARRAY_BUFFER, quadXYCoords, gl.STATIC_DRAW)
gl.BindBuffer(gl.ARRAY_BUFFER, s.texture.quadUV)
gl.BufferData(gl.ARRAY_BUFFER, quadUVCoords, gl.STATIC_DRAW)
}
t := &textureImpl{
id: gl.CreateTexture(),
size: size,
}
gl.BindTexture(gl.TEXTURE_2D, t.id)
gl.TexImage2D(gl.TEXTURE_2D, 0, size.X, size.Y, gl.RGBA, gl.UNSIGNED_BYTE, nil)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
return t, nil
}
func (w *windowImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) {
if !gl.IsProgram(w.s.fill.program) {
p, err := compileProgram(fillVertexSrc, fillFragmentSrc)
if err != nil {
// TODO: initialize this somewhere else we can better handle the error.
panic(err.Error())
}
w.s.fill.program = p
w.s.fill.pos = gl.GetAttribLocation(p, "pos")
w.s.fill.mvp = gl.GetUniformLocation(p, "mvp")
w.s.fill.color = gl.GetUniformLocation(p, "color")
w.s.fill.quadXY = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, w.s.fill.quadXY)
gl.BufferData(gl.ARRAY_BUFFER, quadXYCoords, gl.STATIC_DRAW)
}
gl.UseProgram(w.s.fill.program)
writeAff3(w.s.fill.mvp, w.vertexAff3(dr))
r, g, b, a := src.RGBA()
gl.Uniform4f(
w.s.fill.color,
float32(r)/65535,
float32(g)/65535,
float32(b)/65535,
float32(a)/65535,
)
gl.BindBuffer(gl.ARRAY_BUFFER, w.s.fill.quadXY)
gl.EnableVertexAttribArray(w.s.fill.pos)
gl.VertexAttribPointer(w.s.fill.pos, 2, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 4)
gl.DisableVertexAttribArray(w.s.fill.pos)
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shader.models, err = wavefront.Read("spiritframe.obj")
check(err)
e.shader.projectionmatrix = gl.GetUniformLocation(e.shader.program, "u_projectionMatrix")
e.shader.viewmatrix = gl.GetUniformLocation(e.shader.program, "u_viewMatrix")
e.shader.modelmatrix = gl.GetUniformLocation(e.shader.program, "u_modelMatrix")
e.shader.normalmatrix = gl.GetUniformLocation(e.shader.program, "u_normalMatrix")
e.shader.lightdir = gl.GetUniformLocation(e.shader.program, "u_lightDirection")
e.shader.lightmatrix = gl.GetUniformLocation(e.shader.program, "u_lightmatrix")
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "a_vertex")
e.shader.normal = gl.GetAttribLocation(e.shader.program, "a_normal")
e.shader.texcoord = gl.GetAttribLocation(e.shader.program, "a_texCoord")
for _, model := range e.shader.models {
for _, group := range model.Groups {
//颜色
color := group.Material.Ambient
//顶点
data := f32.Bytes(binary.LittleEndian, group.Vertexes...)
vertexCount := len(group.Vertexes) / 3
databuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, databuf)
gl.BufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)
//UV坐标
textcoords := f32.Bytes(binary.LittleEndian, group.Textcoords...)
uvbuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, uvbuf)
gl.BufferData(gl.ARRAY_BUFFER, textcoords, gl.STATIC_DRAW)
//发现坐标
normals := f32.Bytes(binary.LittleEndian, group.Normals...)
normalbuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, normalbuf)
gl.BufferData(gl.ARRAY_BUFFER, normals, gl.STATIC_DRAW)
tex, _ := LoadTexture(group.Material.Texturefile)
e.shape.Objs = append(e.shape.Objs, Obj{vcount: vertexCount, coord: databuf, color: color, uvcoord: uvbuf, tex: tex, normal: normalbuf})
}
}
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shader.models, err = wavefront.Read("girl.obj")
check(err)
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.vertTexCoord = gl.GetAttribLocation(e.shader.program, "vertTexCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.modelx = gl.GetUniformLocation(e.shader.program, "modelx")
e.shader.modely = gl.GetUniformLocation(e.shader.program, "modely")
e.shader.color = gl.GetUniformLocation(e.shader.program, "color")
e.shader.useuv = gl.GetUniformLocation(e.shader.program, "useuv")
for _, model := range e.shader.models {
for _, group := range model.Groups {
//颜色
color := group.Material.Ambient
//顶点
data := f32.Bytes(binary.LittleEndian, group.Vertexes...)
vertexCount := len(group.Vertexes) / 3
databuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, databuf)
gl.BufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)
//UV坐标
textcoords := f32.Bytes(binary.LittleEndian, group.Textcoords...)
uvbuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, uvbuf)
gl.BufferData(gl.ARRAY_BUFFER, textcoords, gl.STATIC_DRAW)
//贴图文件
var useuv bool
tex, err := LoadTexture(group.Material.Texturefile)
if err != nil {
useuv = false
} else {
useuv = true
}
e.shape.Objs = append(e.shape.Objs, Obj{vcount: vertexCount, coord: databuf, color: color, useuv: useuv, uvcoord: uvbuf, tex: tex})
}
}
}
func onStart() {
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA)
texture := loadImages("495.png")
textureId = gl.CreateTexture()
gl.BindTexture(gl.TEXTURE_2D, textureId)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
gl.TexImage2D(gl.TEXTURE_2D, 0, texture.Rect.Size().X, texture.Rect.Size().Y, gl.RGBA, gl.UNSIGNED_BYTE, texture.Pix)
// loading Shaders & linking programs
program = createProgram("vShader.vs", "fShader.vs")
texProgram = createProgram("vTexShader.vs", "fTexShader.vs")
quadBuffer = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, quadBuffer)
gl.BufferData(gl.ARRAY_BUFFER, quadData, gl.STATIC_DRAW)
quadTexBuffer = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, quadTexBuffer)
gl.BufferData(gl.ARRAY_BUFFER, quadTexData, gl.STATIC_DRAW)
swasBuffer = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, swasBuffer)
gl.BufferData(gl.ARRAY_BUFFER, swastikaData, gl.STATIC_DRAW)
position = gl.GetAttribLocation(program, "position")
color = gl.GetUniformLocation(program, "color")
matrixId = gl.GetUniformLocation(program, "rotationMatrix")
resolutionId = gl.GetUniformLocation(program, "resIndex")
position2 = gl.GetAttribLocation(texProgram, "position")
textureCoords = gl.GetAttribLocation(texProgram, "texCoords")
matrixId2 = gl.GetUniformLocation(texProgram, "rotationMatrix")
resolutionId2 = gl.GetUniformLocation(texProgram, "resIndex")
color2 = gl.GetUniformLocation(texProgram, "color")
}
func uniformLocation(prog gl.Program, name string) gl.Uniform {
attrib := gl.GetUniformLocation(prog, name)
return attrib
}