1/2592000Hz

2026年9月17日木曜日

円と三角のコリジョン

以前師匠の難題７の際にちょっと触れたカリング判定式…検索したらＣＧソフト系の解説で単に３Ｄ処理を軽減する判定…と解説されている記事が見つかりまして。そら、ＣＧツールの利用から考えれば理解する所はそこだけで良いのだけれども…と思って簡単なソースを書いてみました。

そもカリングとは

はい、巻くを意味するカールの動名詞です。それの判定式ですから…

３頂点が右に巻いているか、左に巻いているか、あるいはどちらでも無い（全て同一点もしくは直線状に並んでいる）かの判定に用いられます。

どちらでもなければ０、右／左なら正もしくは負の値を返すのですが…

どちらが右回りでどちらが左回りかは環境によるのでなんとも言えないです、DirectX と OprnGL でも違いましたし、ゲーム機とＣＧツールで齟齬が出た事もありました…すり合わせで地獄を見た記憶が…

カリング判定の計算式

(X1-Px)(Y2-Py)-(X2-Px)(Y1-Py)

えらく簡単です。やっている事は３次元の面法線を外積から求める計算から、必要な部分だけを抽出した計算式…らしいのですが、正直外積の理解がイマイチなので綺麗に説明できません。

ちなみに面法線とは Blender では水色に見えるコレ（面に垂直に立つ面の向いている方向を示すベクトル）の事で、コレが手前に向いているか奥に向いているかを抽出しています。

表示処理の軽減：裏面省略

サイコロのような立方体を考えた際、これを３角ポリゴンで表現するとして…

これらの表面に例えば右巻きのマークを描きます。

で、このサイコロを回してみたらどうなるか？を考えてみましょう。

裏面…というか手前側から観えない面は左巻きになりますよね。

ならば、逆巻になったポリゴンは見えないのだから描画処理を省略すれば良い…というのが裏面省略でした。

…が、最近は光の反射計算等を行っている場合もあるので単純に省略すれば良いと言うものでも無くなってきています。

又、応用として、右巻き／左巻きの面の境界になる辺を線で描画すると輪郭線ができるため、アニメ調のアウトライン処理を行う際にも用いられています。

表示処理の軽減：視界によるオブジェクト省略

この図を上からの俯瞰図ととらえ、三角の下の頂点を視点、三角を視野角の範囲とすると青く変色した×マークが視野角の範囲に入った物で、それ以外は見えていない物になります。

ならば見えていないオブジェクトを省略すれば処理を大きく省略できます。もちろん光の反射等もあるので（以下略

どう判定するのかと言えば…

視野の範囲の三頂点がどちら周りかを調べ…

判定する点と各辺の頂点がどちら周りになるのかを調べます。

これらが全て同じ方向に回転している場合、判定する頂点は三角の中にあると判ります。

視界の範囲…を三角で示しましたが「視界って距離依存だから三角ではなくないか？」という当然の疑問が出ます。はい、正確には円の判定を組み合わせて距離の判定も行います…

円の範囲判定

(Px-Ox)(Px-Ox)+(Py-Oy)(Py-Oy)

これを円の半径の二乗と比較します。式自体はピタゴラスの定理って奴ですね。

直角三角形の底辺の二乗と高さの二乗の値が斜辺の二乗の値に等しいという奴です。

この斜辺の二乗と半径の二乗を比較して半径の二乗の方が大きければ円の範囲内に入っている事になります。

より正確には斜辺の二乗の平方根が斜辺の長さになり（あたり前）、この値と半径の長さを比較すれば良いのだけど、平方根の計算は非常に重い処理である事と、二乗の場合必ず正の値になる為比較が用意である事、各値の絶対値の大小関係と二乗の大小関係が同じである事から二乗の値で比較を行います。

でもって二つの処理を重ねた物がこんな感じ

ソースここから

import pyxel

import random

SCREEN_SIZE_W = 320

SCREEN_SIZE_H = 240

OBJ_MAX = 100

RADIUS = 50

def JudgCircle(px,py,circle_x,circle_y,r):

x = px - circle_x

y = py - circle_y

if r*r >= x*x+y*y:

return True

return False

def JudgCulling(px,py,ax,ay,bx,by):

return (ax-px)*(by-py)-(bx-px)*(ay-py)

def JudgTriangle(px,py,ax,ay,bx,by,cx,cy):

f = JudgCulling(ax,ay,bx,by,cx,cy)

f1 = JudgCulling(px,py,ax,ay,bx,by)

f2 = JudgCulling(px,py,bx,by,cx,cy)

f3 = JudgCulling(px,py,cx,cy,ax,ay)

if f == 0:

return false

if f < 0 and f1 < 0 and f2 < 0 and f3 < 0:

return True

if f > 0 and f1 > 0 and f2 > 0 and f3 > 0:

return True

return False

class Obj:

def __init__(self):

x = 0

y = 0

color = 2

class App:

def __init__(self):

# 画面サイズ 320x240 で初期化

pyxel.init(SCREEN_SIZE_W, SCREEN_SIZE_H, title="judg")

self.object = []

for i in range(OBJ_MAX):

self.object.append(Obj())

self.object[i].x = random.randint(0,SCREEN_SIZE_W)

self.object[i].y = random.randint(0,SCREEN_SIZE_H)

self.object[i].color = 2

pyxel.run(self.update, self.draw)

def update(self):

pass

def draw(self):

# 画面を黒（色番号0）でクリア

pyxel.cls(0)

mx = pyxel.mouse_x

my = pyxel.mouse_y

t1x = mx + int(RADIUS/2)

t1y = my - RADIUS

t2x = mx - int(RADIUS/2)

t2y = my - RADIUS

pyxel.circb(mx,my,RADIUS,15)

pyxel.line(mx,my,t1x,t1y,15)

pyxel.line(mx,my,t2x,t2y,15)

pyxel.line(t1x,t1y,t2x,t2y,15)

for i in range(OBJ_MAX):

self.object[i].color = 2

if JudgCircle(self.object[i].x,self.object[i].y,mx,my,RADIUS):

if JudgTriangle(self.object[i].x,self.object[i].y,mx,my,t1x,t1y,t2x,t2y):

self.object[i].color = 3

pyxel.line(self.object[i].x-5,self.object[i].y-5,

self.object[i].x+5,self.object[i].y+5,

self.object[i].color)

pyxel.line(self.object[i].x+5,self.object[i].y-5,

self.object[i].x-5,self.object[i].y+5,

self.object[i].color)

App()

ソースここまで

…三角だけの時とそこまで変わらなくない？という気がしないでもないですが、オブジェクト表示そのものを省略できるならかなりの軽量化になりますし、

円の判定計算は観ての通り非常に軽いのでやっておいて損は無いと思います。

はい、そんなわけで円と三角のコリジョン判定式でした

ぶっちゃけた話、２Ｄアクションゲームの当たり判定のほとんどはこの二つの式で片付きます。昔はよく取り扱ったなあと思い、書いてみました。

2026年9月15日火曜日

これはなつかしい

東方紅魔郷ＮＣ

Steam見たら懐かしいものが見えて思わず購入…

だいぶ前に、東方はＵＳＢ接続のＳＥＧＡコントローラーが壊れたため、当時エクストラを攻略中だった地霊殿を最後に引退した…と、書いていたのですが、今の私にはセガコン用コンバータと純正のセガコンがあるのですよ。

これならチョン避けできるはず…

初見でなんとかEasy咲夜さん倒せましたが…

多分、１５年ぶり位に紅魔郷をプレー

まず言えるのが画面がすごい見やすい。そして、意外と自機もボスもデカかったんだなあと思いました。

あと、３面あたりからぼちぼちピチュったのですが…。

咲夜さんの所で、やっと低速ボタンに気づく。そうか、ショットボタン押しっぱなしで低速になるのは後の作品だったかと。

あと、低速にならないと自分の当たり判定出ないから霊夢と言えどかすりが分かりづらい。

案外覚えているものもありまして

イージー名物のチルノの正面安地は健在。当時はバカの代名詞でした。

やっぱり避けられないメイド秘技

イージーでも２度も軌道が変わる。老眼のじじいに気合避けは無理ですがな。

…うーん頑張ってフランちゃん討伐までやろうかなあ…

地霊まではＥＸ攻略してたんですけどねえ…いかんせん体が当時の様に動きません、特に目が…

2026年9月12日土曜日

師匠の難題８

〆たばかりだったのですが、前回アップしたソースを修正して一つ気づいた部分がありまして…

どうせやるならタイルコピーによる疑似アルファ処理を追加しようかな？と。

タイル処理による疑似アルファとはなんぞや？という話ですが、コレは９０年代に見られた処理で…以前行った大カプコン展でもちらっと紹介されてました。

５０％タイル

２５％タイル

はい、２×２ドットの範囲で転送するドットとしないドットを決める事で疑似的に半透明っぽく見せる処理です。

又、表示するドットをずらす事で重なりを表現する事も可能です…

こうしてみると、全て転送した時に比べて画像のノイジーさがあまり気にならなくなりますね…

コードはかなり冗長になりますので…定数定義の部分と RollBlt クラスのみ抜粋

ソースここから

import pyxel

SCREEN_SIZE_W = 160

SCREEN_SIZE_H = 120

CENTER_X = 80

CENTER_Y = 60

EMPTY = -32767

ALPHA_NON = 0

ALPHA_HALF_1 = 1

ALPHA_HALF_2 = 2

ALPHA_QUARTER_1 = 3

ALPHA_QUARTER_2 = 4

ALPHA_QUARTER_3 = 5

ALPHA_QUARTER_4 = 6

中略：第７回参照

class RollBlt:

def __init__(self):

self.buff = []

for i in range(SCREEN_SIZE_H):

self.buff.append(LineBuffer())

self.top = 0

self.bottom = 0

self.vbre = VBresenham()

self.bre = Bresenham()

def setup(self):

pass

# 原点座標中央位置補正コピー

def blt_c(self,dest_x, dest_y, bank, src_x, src_y, src_w, src_h, angle, scale_w=128, scale_h=128,alpha=ALPHA_NON):

h = src_h * scale_h >> 8

w = src_w * scale_w >> 8

x = dest_x - my_sin(angle,h) - my_sin(angle+32,w)

y = dest_y - my_cos(angle,h) - my_cos(angle+32,w)

self.blt(x, y, bank, src_x, src_y, src_w, src_h, angle, scale_w, scale_h, alpha)

def blt(self,dest_x, dest_y, bank, src_x, src_y, src_w, src_h, angle, scale_w=128, scale_h=128, alpha=ALPHA_NON):

# 角度のまるめ

angle &= 127

# 原点から見た縦方向の端の座標

h = src_h * scale_h >> 7

tv_x = my_sin(angle,h-1)+dest_x

tv_y = my_cos(angle,h-1)+dest_y

# 原点から見た横方向の端の座標

w = src_w * scale_w >> 7

th_x = my_sin(angle+32,w-1)+dest_x

th_y = my_cos(angle+32,w-1)+dest_y

# ４頂点と比較し上下の座標を求める

self.top = dest_y

if tv_y < self.top:

self.top = tv_y

if th_y < self.top:

self.top = th_y

if (tv_y + th_y - dest_y) < self.top:

self.top = tv_y + th_y - dest_y

if self.top < 0:

self.top = 0

self.bottom = dest_y

if tv_y > self.bottom:

self.bottom = tv_y

if th_y > self.bottom:

self.bottom = th_y

if (tv_y + th_y - dest_y) > self.bottom:

self.bottom = tv_y + th_y - dest_y

if self.bottom > (SCREEN_SIZE_H-1):

self.bottom = SCREEN_SIZE_H-1

# テーブル初期化

for y in range (self.top, self.bottom+1):

self.buff[y].l = EMPTY

self.buff[y].r = EMPTY

# 画像縦方向処理

reg = self.vbre.setup(dest_x,dest_y,tv_x,tv_y)

self.bre.setup(src_h-1,reg-1)

match angle:

# 垂直にコピーする時は縦方向の処理を行わない

case a if a == 32 or a == 96:

pass

case a if a < 32:

for i in range (reg):

x,y = self.vbre.step()

add_src_y = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].l == EMPTY:

self.buff[y].l = x

#pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x

self.buff[y].src_sy = src_y + add_src_y

x = x - dest_x + th_x

y = y - dest_y + th_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].r = x

#pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + src_w-1

self.buff[y].src_ty = src_y + add_src_y

case a if a < 64:

for i in range (reg):

x,y = self.vbre.step()

add_src_y = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].r = x

#pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x

self.buff[y].src_ty = src_y + add_src_y

x = x - dest_x + th_x

y = y - dest_y + th_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].l == EMPTY:

self.buff[y].l = x

#pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + src_w-1

self.buff[y].src_sy = src_y + add_src_y

case a if a < 96:

for i in range (reg):

x,y = self.vbre.step()

add_src_y = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].r == EMPTY:

self.buff[y].r = x

#pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x

self.buff[y].src_ty = src_y + add_src_y

x = x - dest_x + th_x

y = y - dest_y + th_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].l = x

#pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + src_w-1

self.buff[y].src_sy = src_y + add_src_y

case _:

for i in range (reg):

x,y = self.vbre.step()

add_src_y = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].l = x

#pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x

self.buff[y].src_sy = src_y + add_src_y

x = x - dest_x + th_x

y = y - dest_y + th_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].r == EMPTY:

self.buff[y].r = x

#pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + src_w-1

self.buff[y].src_ty = src_y + add_src_y

# 画像横方向処理

reg = self.vbre.setup(dest_x,dest_y,th_x,th_y)

self.bre.setup(src_w-1,reg-1)

match angle:

# 水平にコピーする時は横方向の処理を行わない

case a if angle == 0 or angle == 64:

pass

case a if a < 32:

for i in range (reg):

x,y = self.vbre.step()

add_src_x = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].l == EMPTY:

self.buff[y].l = x

#pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + add_src_x

self.buff[y].src_sy = src_y

x = x - dest_x + tv_x

y = y - dest_y + tv_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].r = x

#pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + add_src_x

self.buff[y].src_ty = src_y + src_h-1

case a if a < 64:

for i in range (reg):

x,y = self.vbre.step()

add_src_x = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].l = x

#pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + add_src_x

self.buff[y].src_sy = src_y

x = x - dest_x + tv_x

y = y - dest_y + tv_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].r == EMPTY:

self.buff[y].r = x

#pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + add_src_x

self.buff[y].src_ty = src_y + src_h-1

case a if a < 96:

for i in range (reg):

x,y = self.vbre.step()

add_src_x = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].r == EMPTY:

self.buff[y].r = x

#pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + add_src_x

self.buff[y].src_ty = src_y

x = x - dest_x + tv_x

y = y - dest_y + tv_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].l = x

#pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + add_src_x

self.buff[y].src_sy = src_y + src_h-1

case _:

for i in range (reg):

x,y = self.vbre.step()

add_src_x = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].r = x

#pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + add_src_x

self.buff[y].src_ty = src_y

x = x - dest_x + tv_x

y = y - dest_y + tv_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].l == EMPTY:

self.buff[y].l = x

#pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + add_src_x

self.buff[y].src_sy = src_y + src_h-1

# バッファを基に転送を行う

# タイル処理なし

if alpha == ALPHA_NON:

for y in range (self.top, self.bottom+1):

reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)

self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)

sx,sy = self.vbre.step()

old_src = 0

new_src = 0

for x in range (self.buff[y].l,self.buff[y].r+1):

new_src = self.bre.step()

for step_src in range (old_src, new_src):

sx,sy = self.vbre.step()

old_src = new_src

# 画面左右端処理

if x < 0:

continue

if x >= SCREEN_SIZE_W:

break

pyxel.blt(x, y, 0, sx, sy, 1, 1)

# タイル処理５０％　１

if alpha == ALPHA_HALF_1:

for y in range (self.top, self.bottom+1):

reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)

self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)

sx,sy = self.vbre.step()

old_src = 0

new_src = 0

for x in range (self.buff[y].l,self.buff[y].r+1):

new_src = self.bre.step()

for step_src in range (old_src, new_src):

sx,sy = self.vbre.step()

old_src = new_src

# 画面左右端処理

if x < 0:

continue

if x >= SCREEN_SIZE_W:

break

if x&1 == y&1:

pyxel.blt(x, y, 0, sx, sy, 1, 1)

# タイル処理５０％　２

if alpha == ALPHA_HALF_2:

for y in range (self.top, self.bottom+1):

reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)

self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)

sx,sy = self.vbre.step()

old_src = 0

new_src = 0

for x in range (self.buff[y].l,self.buff[y].r+1):

new_src = self.bre.step()

for step_src in range (old_src, new_src):

sx,sy = self.vbre.step()

old_src = new_src

# 画面左右端処理

if x < 0:

continue

if x >= SCREEN_SIZE_W:

break

if x&1 != y&1:

pyxel.blt(x, y, 0, sx, sy, 1, 1)

# タイル処理２５％　１

if alpha == ALPHA_QUARTER_1:

for y in range (self.top, self.bottom+1):

reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)

self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)

sx,sy = self.vbre.step()

old_src = 0

new_src = 0

for x in range (self.buff[y].l,self.buff[y].r+1):

new_src = self.bre.step()

for step_src in range (old_src, new_src):

sx,sy = self.vbre.step()

old_src = new_src

# 画面左右端処理

if x < 0:

continue

if x >= SCREEN_SIZE_W:

break

if (x&1) + (y&1)==0:

pyxel.blt(x, y, 0, sx, sy, 1, 1)

# タイル処理２５％　２

if alpha == ALPHA_QUARTER_2:

for y in range (self.top, self.bottom+1):

reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)

self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)

sx,sy = self.vbre.step()

old_src = 0

new_src = 0

for x in range (self.buff[y].l,self.buff[y].r+1):

new_src = self.bre.step()

for step_src in range (old_src, new_src):

sx,sy = self.vbre.step()

old_src = new_src

# 画面左右端処理

if x < 0:

continue

if x >= SCREEN_SIZE_W:

break

if ((x+1)&1) + (y&1)==0:

pyxel.blt(x, y, 0, sx, sy, 1, 1)

# タイル処理２５％　３

if alpha == ALPHA_QUARTER_3:

for y in range (self.top, self.bottom+1):

reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)

self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)

sx,sy = self.vbre.step()

old_src = 0

new_src = 0

for x in range (self.buff[y].l,self.buff[y].r+1):

new_src = self.bre.step()

for step_src in range (old_src, new_src):

sx,sy = self.vbre.step()

old_src = new_src

# 画面左右端処理

if x < 0:

continue

if x >= SCREEN_SIZE_W:

break

if (x&1) + ((y+1)&1)==0:

pyxel.blt(x, y, 0, sx, sy, 1, 1)

# タイル処理２５％　４

if alpha == ALPHA_QUARTER_4:

for y in range (self.top, self.bottom+1):

reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)

self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)

sx,sy = self.vbre.step()

old_src = 0

new_src = 0

for x in range (self.buff[y].l,self.buff[y].r+1):

new_src = self.bre.step()

for step_src in range (old_src, new_src):

sx,sy = self.vbre.step()

old_src = new_src

# 画面左右端処理

if x < 0:

continue

if x >= SCREEN_SIZE_W:

break

if (x&1) + (y&1)==2:

pyxel.blt(x, y, 0, sx, sy, 1, 1)

class App:

def __init__(self):

# 画面サイズ 160x120 で初期化

pyxel.init(SCREEN_SIZE_W, SCREEN_SIZE_H, title="RollBlt")

self.add_x = 0

pyxel.load("yajirushi.pyxres")

self.rb = RollBlt()

self.angle = 0

self.angle2 = 0

pyxel.run(self.update, self.draw)

def update(self):

self.angle += 1

self.angle &= 127

self.angle2 -= 1

self.angle2 &= 127

def draw(self):

# 画面を黒（色番号0）でクリア

pyxel.cls(0)

#self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=64,scale_h=64)

#self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=256,scale_h=64)

"""

self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_HALF_1)

self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_HALF_2)

"""

self.rb.blt_c(CENTER_X-30, CENTER_Y-20, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_1)

self.rb.blt_c(CENTER_X-30, CENTER_Y+20, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_4)

self.rb.blt_c(CENTER_X+30, CENTER_Y-20, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_2)

self.rb.blt_c(CENTER_X+30, CENTER_Y+20, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_3)

App()

ソースここまで

各 ALPHA が if 文で括られていますが違いは Pyxel.Blt を呼ぶかの判定式のみ

ただ、再三書いている通り、ループの中に分岐を書くのでは無く、分岐の中にループを書かないと処理が重くなるのでこのような冗長な記述になります。

…というか、この４重アルファの時点で Celeron ２コアマシンでは処理落ちが始まるのですよ…以前、処理の遅さを感じられるからプログラミングの訓練にはロースペックマシンが良いと書いたのですが、いきなり実感する事になりました。

さすがにこれ以上の発展は…やり始めるとパレットモードで３Ｄモデルを表示するだのおかしな話になりますし、そうなると Python より C++ で書かせろという話になります。

いや、ゲーム自体を作れば…は流石に何年かかるか判りませんし…又なにかあったら追記するかもしれませんが、ひとまずこれでホントの締めになると思います。

2026年9月11日金曜日

師匠の難題７

はい、今回予告通り〆となります。

ソースここから

import pyxel

SCREEN_SIZE_W = 160

SCREEN_SIZE_H = 120

CENTER_X = 80

CENTER_Y = 60

EMPTY = -32767

my_table = (

省略：第５回参照

def my_sin(angle,r):

省略：第５回参照

def my_cos(angle,r):

省略：第５回参照

class VBresenham:

省略：第５回参照

class Bresenham:

省略：第５回参照

class LineBuffer:

省略：第５回参照

class RollBlt:

def __init__(self):

self.buff = []

for i in range(SCREEN_SIZE_H):

self.buff.append(LineBuffer())

self.top = 0

self.bottom = 0

self.vbre = VBresenham()

self.bre = Bresenham()

def setup(self):

pass

# 原点座標中央位置補正コピー

def blt_c(self,dest_x, dest_y, bank, src_x, src_y, src_w, src_h, angle, scale_w=128, scale_h=128):

h = src_h * scale_h >> 8

w = src_w * scale_w >> 8

x = dest_x - my_sin(angle,h) - my_sin(angle+32,w)

y = dest_y - my_cos(angle,h) - my_cos(angle+32,w)

self.blt(x, y, bank, src_x, src_y, src_w, src_h, angle, scale_w, scale_h)

def blt(self,dest_x, dest_y, bank, src_x, src_y, src_w, src_h, angle, scale_w=128, scale_h=128):

# 角度のまるめ

angle &= 127

# 原点から見た縦方向の端の座標

h = src_h * scale_h >> 7

tv_x = my_sin(angle,h-1)+dest_x

tv_y = my_cos(angle,h-1)+dest_y

# 原点から見た横方向の端の座標

w = src_w * scale_w >> 7

th_x = my_sin(angle+32,w-1)+dest_x

th_y = my_cos(angle+32,w-1)+dest_y

# ４頂点と比較し上下の座標を求める

self.top = dest_y

if tv_y < self.top:

self.top = tv_y

if th_y < self.top:

self.top = th_y

if (tv_y + th_y - dest_y) < self.top:

self.top = tv_y + th_y - dest_y

if self.top < 0:

self.top = 0

self.bottom = dest_y

if tv_y > self.bottom:

self.bottom = tv_y

if th_y > self.bottom:

self.bottom = th_y

if (tv_y + th_y - dest_y) > self.bottom:

self.bottom = tv_y + th_y - dest_y

if self.bottom > (SCREEN_SIZE_H-1):

self.bottom = SCREEN_SIZE_H-1

# テーブル初期化

for y in range (self.top, self.bottom+1):

self.buff[y].l = EMPTY

self.buff[y].r = EMPTY

# 画像縦方向処理

reg = self.vbre.setup(dest_x,dest_y,tv_x,tv_y)

self.bre.setup(src_h-1,reg-1)

match angle:

# 垂直にコピーする時は縦方向の処理を行わない

case a if a == 32 or a == 96:

pass

case a if a < 32:

for i in range (reg):

x,y = self.vbre.step()

add_src_y = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].l == EMPTY:

self.buff[y].l = x

pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x

self.buff[y].src_sy = src_y + add_src_y

x = x - dest_x + th_x

y = y - dest_y + th_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].r = x

pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + src_w-1

self.buff[y].src_ty = src_y + add_src_y

case a if a < 64:

for i in range (reg):

x,y = self.vbre.step()

add_src_y = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].r = x

pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x

self.buff[y].src_ty = src_y + add_src_y

x = x - dest_x + th_x

y = y - dest_y + th_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].l == EMPTY:

self.buff[y].l = x

pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + src_w-1

self.buff[y].src_sy = src_y + add_src_y

case a if a < 96:

for i in range (reg):

x,y = self.vbre.step()

add_src_y = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].r == EMPTY:

self.buff[y].r = x

pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x

self.buff[y].src_ty = src_y + add_src_y

x = x - dest_x + th_x

y = y - dest_y + th_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].l = x

pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + src_w-1

self.buff[y].src_sy = src_y + add_src_y

case _:

for i in range (reg):

x,y = self.vbre.step()

add_src_y = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].l = x

pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x

self.buff[y].src_sy = src_y + add_src_y

x = x - dest_x + th_x

y = y - dest_y + th_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].r == EMPTY:

self.buff[y].r = x

pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + src_w-1

self.buff[y].src_ty = src_y + add_src_y

# 画像横方向処理

reg = self.vbre.setup(dest_x,dest_y,th_x,th_y)

self.bre.setup(src_w-1,reg-1)

match angle:

# 水平にコピーする時は横方向の処理を行わない

case a if angle == 0 or angle == 64:

pass

case a if a < 32:

for i in range (reg):

x,y = self.vbre.step()

add_src_x = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].l == EMPTY:

self.buff[y].l = x

pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + add_src_x

self.buff[y].src_sy = src_y

x = x - dest_x + tv_x

y = y - dest_y + tv_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].r = x

pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + add_src_x

self.buff[y].src_ty = src_y + src_h-1

case a if a < 64:

for i in range (reg):

x,y = self.vbre.step()

add_src_x = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].l = x

pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + add_src_x

self.buff[y].src_sy = src_y

x = x - dest_x + tv_x

y = y - dest_y + tv_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].r == EMPTY:

self.buff[y].r = x

pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + add_src_x

self.buff[y].src_ty = src_y + src_h-1

case a if a < 96:

for i in range (reg):

x,y = self.vbre.step()

add_src_x = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].r == EMPTY:

self.buff[y].r = x

pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + add_src_x

self.buff[y].src_ty = src_y

x = x - dest_x + tv_x

y = y - dest_y + tv_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].l = x

pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + add_src_x

self.buff[y].src_sy = src_y + src_h-1

case _:

for i in range (reg):

x,y = self.vbre.step()

add_src_x = self.bre.step()

# MainSide

if y >= 0 and y < SCREEN_SIZE_H:

self.buff[y].r = x

pyxel.pset(x,y,6)

self.buff[y].src_tx = src_x + add_src_x

self.buff[y].src_ty = src_y

x = x - dest_x + tv_x

y = y - dest_y + tv_y

# SubSide

if y >= 0 and y < SCREEN_SIZE_H:

if self.buff[y].l == EMPTY:

self.buff[y].l = x

pyxel.pset(x,y,6)

self.buff[y].src_sx = src_x + add_src_x

self.buff[y].src_sy = src_y + src_h-1

# バッファを基に転送を行う

for y in range (self.top, self.bottom+1):

reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)

self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)

sx,sy = self.vbre.step()

old_src = 0

new_src = 0

for x in range (self.buff[y].l,self.buff[y].r+1):

new_src = self.bre.step()

for step_src in range (old_src, new_src):

sx,sy = self.vbre.step()

old_src = new_src

# 画面左右端処理

if x < 0:

continue

if x >= SCREEN_SIZE_W:

break

pyxel.blt(x, y, 0, sx, sy, 1, 1)

class App:

def __init__(self):

# 画面サイズ 160x120 で初期化

pyxel.init(SCREEN_SIZE_W, SCREEN_SIZE_H, title="RollBlt")

self.add_x = 0

pyxel.load("yajirushi.pyxres")

self.rb = RollBlt()

self.angle = 0

pyxel.run(self.update, self.draw)

def update(self):

self.angle += 1

self.angle &= 127

def draw(self):

# 画面を黒（色番号0）でクリア

pyxel.cls(0)

#self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=64,scale_h=64)

#self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=256,scale_h=64)

self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512)

App()

ソースここまで

※画面左右端処理を追記

１２８を基準値とした拡縮／新設した blt_c 関数による中心指定コピー、上下画面外への処理も可能に。ちなみに前回の状態で画面上下にはみ出しても大丈夫ではありました…これは Python の仕様上ラインバッファが配列では無くリストになっていた為、インデックスがマイナスになってもエラーを吐かない為です。とは言え、それを頼ってはいけないので処理は追加しましたが。

拡大すると４５度付近で顕著にズレが生じる事が解ります。なにやら古いＤＶＤのようですね…法則性があるので解決策もありそうですが…

今回長方形の回転を作っていたので、Blt 関数内の各 case 文で原点を中心に辺の計算をした後で、原点を平行移動させて対になる辺の値も作っていました。

角度と長さが同じと判っている為、こうすれば無駄がない為です（各 MainSide SubSide 参照）。

しかし、師匠の最終課題とは…恐らく４頂点を自由移動…つまりポリゴン化だったのではないかと推測します。

セガサターンのポリゴンは「スプライトを変形させた疑似ポリゴン」

…という解説を読んだことはないでしょうか？

疑似も何もポリゴンは多角形の事なので４角形ならポリゴンなのですが。

つまり、これと同様のものを作れ…というのが最終課題だったのではないか？と、思われます。ただ、これは結構な問題で３角形は数学上折れる事は無いのですが４角形は折れたり自分自身と重なったりします。３頂点の中に他の頂点が含まれたか？の判定については、カリング判定式というものがあり、これも実数も割り算も使わない古いやり方があるのですが…

※９／１７追記

セガサターンのスプライト変形は今回の処理と違い元画像を主体とした画像の転送であり、どちらかと言うと第４回の時の処理に近い物のようです。

最後に白状してしまうと…

四半世紀以上昔の話、一度ゲーム業界を辞めて、一般ソフトハウスに入り、その後もう一度ゲーム業界にカムバックしたのですが。

その際にウィンドウズで DirectX を使わない独自ゲームライブラリを作って、サンプルデモを持ち込み転職した事がありました。

描画関係はほぼ i386 アセンブラ（一部 MMX Pentium ）を使用しており、なんならアセンブラ内部からＣ＋＋のメンバー関数を呼ぶといった器用な事もやっていたのですが…

画像転送、アニメーション有りスプライト処理（拡縮はできたが回転はできず）の他に…２５６色パレットモードビットマップを使った３Ｄ処理を作っており、六角大王で作ったデータを変換して３Ｄアニメーションデモを作る…といった処理も組んでいました。

ええ、テクスチャ無しなら４角だろうがポリゴンだろうが円だろうが描画する処理自体は組んだ事があり、それらをＺソートで繋いで表示する事くらいはやっていたのです。

当時ビットマップ回転処理だけできなかったのが心残りでした。

まあ、そんなものを作る性分ですから DirectX どころかアンリアルエンジンやらのライブラリの「借り方」が上手い奴が上に行く当時の風潮や、とにかく新しい言語を覚え続けないといけないという世界に嫌気がさしてしまったんですけどね。

当時の風潮になじめなかったアセンブラバカを始めとするエンジニアの安息の地はどこにあったのでしょうね？久々に真面目にプログラムを組んでそんな事を思いました。

というわけで、実数と割り算を使用しないレトロ縛りの回転画像転送処理を一旦〆たいと思います。本当は年末までかかるかと思ったのですが、一気にやらないと頭から抜け落ちそうだったので押し通しました。

最後に、ゲーム業界でプログラマー１年目だった自分にこれだけの奥の深い課題を出してくれた師匠に最大限の感謝を。

登録: 投稿 (Atom)