mieki256's diary

import sys
import math
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *
from PIL import Image

IMG_NAME = "img_rgba.png"

SCRW, SCRH = 512, 512
FPS = 60

scr_w, scr_h = SCRW, SCRH
window = 0

# Rotation angle for the Quads
rotx = 0.0
roty = 0.0

texture = 0


def load_texture():
    global texture

    # load image by using PIL
    im = Image.open(IMG_NAME)
    w, h = im.size
    print("Image: %d x %d, %s" % (w, h, im.mode))

    if im.mode == "RGB":
        # RGB convert to RGBA
        im.putalpha(alpha=255)
    elif im.mode == "L" or im.mode == "P":
        # Grayscale, Index Color convert to RGBA
        im = im.convert("RGBA")

    raw_image = im.tobytes()

    ttype = GL_RGBA
    if im.mode == "RGB":
        ttype = GL_RGB
        print("Set GL_RGB")
    elif im.mode == "RGBA":
        ttype = GL_RGBA
        print("Set GL_RGBA")

    glBindTexture(GL_TEXTURE_2D, glGenTextures(1))

    # glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4)

    # set texture
    glTexImage2D(
        GL_TEXTURE_2D,      # target
        0,                  # MIPMAP level
        ttype,              # texture type (RGB, RGBA)
        w,                  # texture image width
        h,                  # texture image height
        0,                  # border width
        ttype,              # texture type (RGB, RGBA)
        GL_UNSIGNED_BYTE,   # data is unsigne char
        raw_image,          # texture data pointer
    )

    glClearColor(0, 0, 0, 0)
    glShadeModel(GL_SMOOTH)

    # set texture repeat
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)

    # set texture filter
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
    # glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND)


def set_billboard_matrix():
    m = glGetDoublev(GL_MODELVIEW_MATRIX)
    m[0][0] = m[1][1] = m[2][2] = 1.0
    m[0][1] = m[0][2] = 0.0
    m[1][0] = m[1][2] = 0.0
    m[2][0] = m[2][1] = 0.0
    glLoadMatrixd(m)


def draw_gl():
    global rotx, roty

    glClearColor(0.125, 0.25, 0.5, 0.0)  # background color
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    glLoadIdentity()  # Reset The View

    # move camera
    r = 12.0
    ex = r * math.cos(math.radians(roty + 90.0))
    ey = 5.0
    ez = r * math.sin(math.radians(roty + 90.0))
    tx, ty, tz = 0.0, 0.0, 0.0
    gluLookAt(ex, ey, ez, tx, ty, tz, 0, 1, 0)

    glEnable(GL_BLEND)
    glEnable(GL_TEXTURE_2D)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

    glColor4f(1.0, 1.0, 1.0, 1.0)  # color

    # draw floor quads
    glPushMatrix()

    w = 5.0
    glBegin(GL_QUADS)

    glTexCoord2f(0.0, 0.0)  # set u, v
    glVertex3f(-w, 0.0, -w)  # Top Left

    glTexCoord2f(1.0, 0.0)
    glVertex3f(w, 0.0, -w)  # Top Right

    glTexCoord2f(1.0, 1.0)
    glVertex3f(w, 0.0, w)  # Bottom Right

    glTexCoord2f(0.0, 1.0)
    glVertex3f(-w, 0.0, w)  # Bottom Left

    glEnd()
    glPopMatrix()

    # draw object quads
    for i in range(0, 300, 20):
        x = 5.0 * math.cos(math.radians(i))
        y = 0.0
        z = 5.0 * math.sin(math.radians(i))

        glPushMatrix()
        glTranslatef(x, y, z)  # translate

        set_billboard_matrix()

        glBegin(GL_QUADS)

        glTexCoord2f(0.0, 0.0)  # set u, v
        glVertex3f(-1.0, 2.0, 0)  # Top Left

        glTexCoord2f(1.0, 0.0)
        glVertex3f(1.0, 2.0, 0.0)  # Top Right

        glTexCoord2f(1.0, 1.0)
        glVertex3f(1.0, 0.0, 0.0)  # Bottom Right

        glTexCoord2f(0.0, 1.0)
        glVertex3f(-1.0, 0.0, 0.0)  # Bottom Left

        glEnd()
        glPopMatrix()

    glDisable(GL_TEXTURE_2D)

    glutSwapBuffers()


def init_viewport_and_pers(width, height):
    # Prevent A Divide By Zero If The Window Is Too Small
    if height == 0:
        height = 1

    scr_w, scr_h = width, height

    # Reset The Current Viewport And Perspective Transformation
    glViewport(0, 0, width, height)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()  # Reset The Projection Matrix

    # Calculate The Aspect Ratio Of The Window
    # gluPerspective(fovy, aspect, zNear, zFar )
    gluPerspective(60.0, float(width) / float(height), 0.1, 100.0)
    glMatrixMode(GL_MODELVIEW)


def InitGL(width, height):
    glClearColor(0.125, 0.25, 0.5, 0.0)  # background color
    glClearDepth(1.0)  # Enables Clearing Of The Depth Buffer
    glEnable(GL_DEPTH_TEST)  # Enables Depth Testing
    glDepthFunc(GL_LESS)  # The Type Of Depth Test To Do
    glShadeModel(GL_SMOOTH)  # Enables Smooth Color Shading

    init_viewport_and_pers(width, height)


def resize_gl(width, height):
    init_viewport_and_pers(width, height)


def on_timer(value):
    global rotx, roty
    rotx = 0.0
    roty = roty + 0.5
    glutPostRedisplay()
    glutTimerFunc(int(1000 / FPS), on_timer, 0)


def key_pressed(key, x, y):
    # If escape is pressed, kill everything.
    ESCAPE = b"\x1b"
    if key == ESCAPE or key == b'q':
        if glutLeaveMainLoop:
            glutLeaveMainLoop()
        else:
            sys.exit()


def main():
    global window

    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)

    glutInitWindowSize(SCRW, SCRH)
    # glutInitWindowPosition(0, 0)

    window = glutCreateWindow(b"Draw texture")

    glutDisplayFunc(draw_gl)
    glutReshapeFunc(resize_gl)
    glutKeyboardFunc(key_pressed)
    # glutFullScreen()

    # glutIdleFunc(draw_gl)
    glutTimerFunc(int(1000 / FPS), on_timer, 0)

    InitGL(SCRW, SCRH)

    load_texture()

    glutMainLoop()


if __name__ == "__main__":
    print("Hit ESC key to quit.")
    main()

def set_billboard_matrix():
    m = glGetDoublev(GL_MODELVIEW_MATRIX)
    m[0][0] = m[1][1] = m[2][2] = 1.0
    m[0][1] = m[0][2] = 0.0
    m[1][0] = m[1][2] = 0.0
    m[2][0] = m[2][1] = 0.0
    glLoadMatrixd(m)

m[0][0]  m[1][0]  m[2][0]  m[3][0]
m[0][1]  m[1][1]  m[2][1]  m[3][1]
m[0][2]  m[1][2]  m[2][2]  m[3][2]
m[0][3]  m[1][3]  m[2][3]  m[3][3]

    glDepthMask(GL_FALSE)
    glDepthFunc(GL_LEQUAL)

    # draw billboard ...

    glDepthMask(GL_TRUE)
    glDepthFunc(GL_LESS)

    glAlphaFunc(GL_GREATER, 0.5)
    glEnable(GL_ALPHA_TEST)

    # draw billboard ...

    glDisable(GL_ALPHA_TEST)

• glEnable(GL_ALPHA_TEST) や glDisable(GL_ALPHA_TEST) は、alpha test という処理を有効化/無効化している。
• glAlphaFunc(GL_GREATER, 0.5) は、アルファチャンネルのしきい値を設定している。

    if USE_DEPTHMASK:
        glDepthMask(GL_TRUE)
        glDepthFunc(GL_LESS)
    else:
        glDepthMask(GL_FALSE)
        glDepthFunc(GL_LEQUAL)

    # record position
    pos = []
    for i in range(0, 300, 20):
        x = 5.0 * math.cos(math.radians(i))
        y = 0.0
        z = 5.0 * math.sin(math.radians(i))

        if GET_DISTANCE:
            # get distance from camera to billboard
            dx = x - cam_pos[0]
            dy = y - cam_pos[1]
            dz = z - cam_pos[2]
            dist = dx * dx + dy * dy + dz * dz
            pos.append([x, y, z, dist])
        else:
            # get z value
            glPushMatrix()
            glTranslatef(x, y, z)  # translate
            
            m = glGetDoublev(GL_MODELVIEW_MATRIX)
            tx, ty, tz = m[3][0], m[3][1], m[3][2]
            
            pos.append([x, y, z, tz])
            glPopMatrix()

    # sort billboard
    s_pos = sorted(pos, key=lambda x: x[3])
    
    if GET_DISTANCE:
        s_pos.reverse()

    for p in s_pos:
        x, y, z, _ = p
        
        # draw billboard

sudo apt purge sonic-pi scratch scratch2 scratch3
sudo apt autoremove

u"""
pi3d input keyboard with pygame or InputEvents sample.

Sample script to get keyboard input.
Move the sprite up, down, left and right with WASD key or cursor key.

use pygame.key.get_pressed / pi3d.InputEvents.

Press ESC key to exit.

Windows10 x64 + Python 2.7.12 32bit + pi3d 2.21 + pygame 1.9.3

Author : mieki256
License : CC0
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import pi3d
import pygame


class KeyboardStatus(object):
    u"""Keyboard status."""

    # referenc :
    # pi3d/event/Keys.py
    # https://www.pygame.org/docs/ref/key.html
    keys_list = {
        "KEY_ESC": pygame.K_ESCAPE,
        "KEY_A": pygame.K_a, "KEY_B": pygame.K_b, "KEY_C": pygame.K_c,
        "KEY_D": pygame.K_d, "KEY_E": pygame.K_e, "KEY_F": pygame.K_f,
        "KEY_G": pygame.K_g, "KEY_H": pygame.K_h, "KEY_I": pygame.K_i,
        "KEY_J": pygame.K_j, "KEY_K": pygame.K_k, "KEY_L": pygame.K_l,
        "KEY_M": pygame.K_m, "KEY_N": pygame.K_n, "KEY_O": pygame.K_o,
        "KEY_P": pygame.K_p, "KEY_Q": pygame.K_q, "KEY_R": pygame.K_r,
        "KEY_S": pygame.K_s, "KEY_T": pygame.K_t, "KEY_U": pygame.K_u,
        "KEY_V": pygame.K_v, "KEY_W": pygame.K_w, "KEY_X": pygame.K_x,
        "KEY_Y": pygame.K_y, "KEY_Z": pygame.K_z,
        "KEY_0": pygame.K_0, "KEY_1": pygame.K_1, "KEY_2": pygame.K_2,
        "KEY_3": pygame.K_3, "KEY_4": pygame.K_4, "KEY_5": pygame.K_5,
        "KEY_6": pygame.K_6, "KEY_7": pygame.K_7, "KEY_8": pygame.K_8,
        "KEY_9": pygame.K_9,
        "KEY_UP": pygame.K_UP, "KEY_DOWN": pygame.K_DOWN,
        "KEY_LEFT": pygame.K_LEFT, "KEY_RIGHT": pygame.K_RIGHT,
        "KEY_SPACE": pygame.K_SPACE
    }

    class PygameKeyStatus(object):
        u"""Keyboard status with pygame."""

        def __init__(self):
            """Init."""
            pygame.init()

        def update(self):
            """Update."""
            pygame.event.pump()
            self.keys = pygame.key.get_pressed()
            pygame.event.clear()

        def key_pressed(self, key_str):
            """Get key press state.

            @param key_str key kind string
            @return True or False

            """
            return self.keys[KeyboardStatus.keys_list[key_str]]

        def close(self):
            """Close."""
            pygame.quit()

    class Pi3dInputKeyState(object):
        """Keyboard status width pi3d.InputEvents."""

        def __init__(self):
            """Init."""
            self.inputs = pi3d.InputEvents()

        def update(self):
            """Update."""
            self.inputs.do_input_events()

        def key_pressed(self, key_str):
            """Get key press state.

            @param key_str key kind string
            @return True or False

            """
            return (self.inputs.key_state(key_str) != 0)

        def close(self):
            """Close."""
            pass

    def __init__(self):
        """Init."""
        self.keyboard = pi3d.Keyboard()
        if pi3d.USE_PYGAME:
            self.state = KeyboardStatus.PygameKeyStatus()
        else:
            self.state = KeyboardStatus.Pi3dInputKeyState()

    def update(self):
        """Update."""
        self.pikey = self.keyboard.read()
        self.state.update()

    def key_pressed(self, key_str):
        """Key press check.

        @param key_str key kind
        @return True or False

        """
        return self.state.key_pressed(key_str)

    def esckey_pressed(self):
        """ESC key press check.

        @return True or False

        """
        return (self.pikey == 27 or self.key_pressed("KEY_ESC"))

    def close(self):
        u"""Close."""
        self.keyboard.close()
        self.state.close()


display = pi3d.Display.create(w=640, h=480, frames_per_second=60)
shader = pi3d.Shader("uv_flat")
camera = pi3d.Camera(is_3d=False)

x, y, z = 0.0, 0.0, 20.0
tex = pi3d.Texture("airplane_01_64x64.png", mipmap=False)
spr = pi3d.ImageSprite(tex, shader, w=64, h=64, x=x, y=y, z=z)
display.add_sprites(spr)

inputs = KeyboardStatus()

while display.loop_running():
    inputs.update()

    spd = 6.0

    if inputs.key_pressed("KEY_W") or inputs.key_pressed("KEY_UP"):
        spr.translateY(spd)
    if inputs.key_pressed("KEY_S") or inputs.key_pressed("KEY_DOWN"):
        spr.translateY(-spd)

    if inputs.key_pressed("KEY_A") or inputs.key_pressed("KEY_LEFT"):
        spr.translateX(-spd)
    if inputs.key_pressed("KEY_D") or inputs.key_pressed("KEY_RIGHT"):
        spr.translateX(spd)

    if inputs.esckey_pressed():
        inputs.close()
        display.destroy()
        break

• Ctrl + C を押してもスクリプトが止まってくれない。
• マウスを動かしてもマウスカーソルが動かないから、ウインドウの閉じるボタンを押せない。

• Windows上で動かす場合は、何も指定しなくても pygame が有効になる。
• Raspberry Pi上で動かす場合は、指定しても pygame が無効になる。
• Linux上で動かす場合は、指定によって pygame の有効/無効が変わる。

sudo apt-get install scrot

• レイズナー方式。
• ライダーカブト方式。
• 主人公交代。

#!ruby -Ks
# DXRubyを使ってフォルダを選択するサンプル

require 'dxruby'

folder = ""
font = Font.new(26)

Window.loop do
  break if Input.keyPush?(K_ESCAPE)

  y = 16
  yh = font.size + 4
  Window.drawFont(10, y, "Push Z key -> Select Folder", font)
  Window.drawFont(10, y + 1 * yh, "Folder:[#{folder}]", font)
  
  if Input.keyPush?(K_Z)
    folder = Window.folder_dialog("folder select")
    if folder == nil
      folder = "Cancel."
    end
  end
end

>>> import markdown2
>>> markdown2.markdown("*em tag* **strong tag**")
u'<p><em>em tag</em> <strong>strong tag</strong></p>\n'

1. 「出現位置記録配列」のインデックスをチェック。置けるはずの全ての位置に置いたか？ 置いたなら、エラーを返す。
2. 乱数でx,yを取得。
3. 取得した x,y は既に出現したか。出現済みなら、2. に戻る。
4. x,y を、「出現位置記録配列」に記録。インデックスを進める。
5. 「パターン配置マップ」を参照。パターンを置こうとしてる場所に別のパターンが書き込まれてないかチェック。書き込まれてたら、1. に戻る。
6. 「パターン配置マップ」にパターンを書き込み。
7. 次に置くパターンの、「出現位置記録配列」を初期化＆先頭に自分の位置を記録。
8. 次に置くパターンを決定。（自身が処理したのと同じ関数を再帰呼び出し）
9. 次に置くパターンが決定できたなら、正常終了を返して、関数を抜ける。エラーが返ってきたら、自分が書き込んだパターンを消去して、1. に戻る.

Operaは、ブラウザ内の広告バナーを取り外しライセンス料金を不要にいたしました。 この画期的なニュースは、Opera の普及と、世界中の ユーザーの皆様からのご支援により、本日発表することが出来ました。 さらに、プレミアムサポートもご用意しております。

つまりはRubyでゲームなどを作るためのライブラリと言えます。

SDLは様々なplatformで動くというのが大きな特徴です。 Linux, Win32, BeOS, MacOS, Solaris, IRIX, FreeBSD は正式にサポートされているとannounceされているもので、さらにNetBSD、OpenBSD、AmigaOS、MacOS Xなどでも動くようです。 1つのソースでこれだけのプラットホームで動く、しかもグラフィックやオーディオを使ったマルチメディアなプログラムを書くことができるというわけです。

月が満ち欠けする理由について「地球から見て太陽と月の位置関係が変わるから」と正しく答えた児童は47%にとどまった。不正解の「月が地球の影に入る」は37%で「いろいろな形の月がある」は2%、「分からない」と無回答が計14%だった。

小学生の知識や理解は危機的状況にあることが

情報があふれる一方、テレビやゲームなどに時間を奪われ、身近な現象を学ぶ機会が減っている