Memeplexes

[PR]

2025年02月26日

[PR]上記の広告は3ヶ月以上新規記事投稿のないブログに表示されています。新しい記事を書く事で広告が消えます。

突然ですがSilverlightでアナログ時計を作ってみました。

はい、そうですね。
おかしいです。
本来１２時のところが０になっています。
でもこれはつまらないバグでこうなったのではありません。
わざとです。
この背景には緻密(?)なロジックがあります。
実は、時計の文字盤はこうであるべきなのです。

今回はユーザーインターフェースの話です。
なんだか冗談のような話ですが、論理は完璧に通っています。
私が考えたのではなく、某所で聞いてなるほどなと思った話ですが・・・。

どういう事かというと、
時計の文字盤から１２時を抹殺せよ！！
１２時はユーザーインターフェースとして不条理だ！
という話です。

１２時→０時

ということですね。

こういう話ではない

ここまでの話を聞いてこう思われる方もいらっしゃるでしょう。
「なるほど。
これはインデクスを0から始めるか1から始めるかという話だな。
現在主流のプログラミング言語では配列の添字を0からスタートさせる。
物を数えるときは0番目から始めるんだ。
だからそれを時計の文字盤にも当てはめようということか。」

いいえ違います！
全然違います。
ものの数え方を0から始めるか1から始めるかなどは慣習で、どうでもいいことなのです。
（さすがにいきなり１２番目から数え始めるというのは問題ですが）
その程度の話なら誰も１２時を抹殺しようとは言わないでしょう。

ここで大切なのは「１からスタートしない」ということではなく、「スタートは０から」ということなのです。
ここには根本的な誤解があります。
実は、１２時を持つ普通の文字盤も、「１からスタートしない」のです。
もちろん「スタートは０から」というわけでもありません。
普通の文字盤は、１２からスタートしているのです。

大きな数からスタートする

ややこしいので図にしてみましょう。
普通の文字盤は、次のように時間が進行していきます。

午後や午前は、まず１２時からスタートします。
大きな数からスタートするのです。
そこから何故か数が減って、１時となります。
そしてその後は普通に数が増えて２時、３時…となります。

これが１２が存在することの理不尽な点です。
普通、物を数えるときには小さな数から大きな数へと推移していきます。
しかし普通の文字盤は違うのです。
はじめに何故か大きな数がやってきて、その後いきなり小さくなり、後はすこしずつ大きくなる。
これを不条理と言わずして何を不条理といえばいいのでしょう！！！？

一方、理想的な文字盤はこうなります。

どうでしょうか。
０から始まりすこしずつ大きくなり１１にたどり着く。
これが直感的なものの数え方というものです。

１２時があるとプログラムが書きにくい

１２時には直感的でないという以上の問題もあります。
時間に関係したプログラムが書きにくいのです。
たとえばある時間と別の時間の時間差を計算するプログラムを書きたいとします。
そのために時間を全て秒に直すとしましょう。

すると直感的にはこのようなプログラムを書きたくなるのではないでしょうか。
（単純化していますが）

        enum DayTimePeriod
        {
            AnteMeridiem = 0,
            PostMeridiem = 1
        }

        int ToSeconds(int day, DayTimePeriod period, int hour, int minute, int second)
        {
            return day * 24 * 60 * 60 
                +(int)period * 12 * 60 * 60
                + hour * 60 * 60 
                + minute * 60 
                + second;
        }

DayTimePeriodは午前か午後かを表します。
AnteMeridiemはAM、PostMeridiemはPMです。
このプログラムは一見正しいように見えるかもしれませんが、hourが12の時正確に動作しません。
12の時は特別扱いをして、0として扱ってやらねばならないのです。

このことは、本質的に１２時の存在は間違っていて、０時こそが正しいということを暗示しています！！

…もっとも.netならSystem.TimeSpan構造体を使えという話ではありますが。

でも本当に１２時を消さなくちゃいけないのか？

「なるほど現行の文字盤に問題はあるようだ。
しかし今まで長年人々が慣れ親しんできた文字盤から１２時を消すことなんて今更出来るだろうか？
それよりは午前午後の境界を一時間ずらして「一時～１２時」にした方がいいんじゃないかな？」
と考える方もいらっしゃるでしょう。

しかし午前午後の境界をずらすというのはあまり美しい方法ではありません。
０時（旧１２時）はその定義が南中時刻に結び付けられています。
地球の自転と太陽の位置とに密接に結びついているのです。
一時間ずらすのはあまりきれいではないのです。
もっともサマータイムはそのずらしを期間限定で行っていますが。

「今更１２時を消せない」という点についてはどうでしょうか。
これも疑問が残ります。

過去にこんな例がありました。
摂氏という単位はみなさんご存知ですね。
温度の単位です。
実はこれは昔、逆だったのです。
水が凍っている時が100℃で沸騰している時が0℃でした。
さすがにそれは分かりにくいということで逆転されたのです。
何を言いたいのかというと、逆転ができたのなら一部変更くらいできてもおかしく有りません！！！！

まあそれはともかく最近は0時と言う人も珍しくありませんので文字盤から12時を消すのも心理的抵抗は以前より少なくなっているのではないかと思います。
大切なのは心理的抵抗をどんどん薄めていくことです。
たとえば同僚の前で「12時」と言う機会があったら代わりに0時というのです。
家の中のアナログ時計にシールで0を貼ります（うーん想像してみたら異様な光景です）。
子供たちにシンデレラを読み聞かせることがあったら、魔法が解けるのは0時です。

こうして人々の心理的抵抗が少なくなっていってそれがある閾値に到達したとき、ばっと情勢がひっくり返ると思うのです。
世の中からは12時文字盤が消え、0時型文字盤が普及するでしょう！
・・・・・・どうでしょうか。
0時型文字盤を普及させる気になってきませんか！？

おまけ

Silverlightアナログ時計のプロジェクトファイルです。
MVVMを使うとデザイン画面で針が動くとは思いませんでした。
SilverlightClock.zip

[0回]

リッチテキストなソースコードをHTMLに変換

ツールを作ってみました。
ブログにソースコードを貼るためのツールです。
Visual Studioからコピー貼付けするとそれがpreで囲まれたhtmlになって出てきます。
つまりリッチテキストからHTMLへの簡単な変換プログラムですね。
クラスやキーワードに色がついて見やすくなるというあれです。

といっても既に似たようなプログラムはたくさん作られています。
まあツール世界の多様性に貢献するという意味で（？？？？）アップしておきます。

ダウンロード

[2回]

XNAで音を合成　DynamicSoundEffectInstanceクラス

突然ですが、 XNA4.0では自在に音を合成できるクラスが用意されているようです。
自在に合成とは一体何を言っているのかというと、こういうことです。

これまでXNAではたしか予め録音された音しか再生できなかったと思います。
ものが爆発した音なら爆発音を最初からファイルに保存しておいてそれを必要なときに再生するという形でした。
しかし新しいMicrosoft.Xna.Framework.Audio.DynamicSoundEffectInstanceクラスはちがいます。
波形データをリアルタイムで作って、それを再生できるのです。

もしかすると物理世界をシミュレートして、その結果として音を鳴らすというようなことが出来るかもしれませんね。
先程の例で言うと爆発時の空気の振動を計算してそれを使えるかもしれませんん。
あるいは音声の合成とかゲームとは別のベクトルで面白そうです。

ではやってみましょう。

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;

namespace XnaDynamicAudio
{
    static class Program
    {
        static void Main(string[] args)
        {
            const int samplePerSecond = 8000;
            const int secondsToPlay = 3;

            using (DynamicSoundEffectInstance dynamicSound = new DynamicSoundEffectInstance(samplePerSecond, AudioChannels.Mono))
            {
                byte[] buffer = createAWave(samplePerSecond, secondsToPlay, 440);
                dynamicSound.SubmitBuffer(buffer);
                FrameworkDispatcher.Update();
                dynamicSound.Play();
                System.Threading.Thread.Sleep(secondsToPlay * 1000);
            }
        }

        private static byte[] createAWave(int samplePerSecond, int secondsToPlay, int heltz)
        {
            byte[] buffer = new byte[samplePerSecond * secondsToPlay];

            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = (byte)(
                    byte.MaxValue / 4 * (1 + Math.Sin((Math.PI * heltz) * i / samplePerSecond))
                    );
            }

            return buffer;
        }
    }
}

このサンプルプログラムを実行すると、ピーという音が鳴ります。
440Hzのサイン波。
つまり、ラの音です。

クラス

このサンプルプログラムに登場した重要なクラスは2つ有ります。
DynamicSoundEffectInstanceクラスとFrameworkDispatcherクラスです。

DynamicSoundEffectInstanceはダイナミックな再生を司るクラスだからいいとして、FrameworkDispatcherとはなんでしょう？
これはXNAで使うコンポーネントを管理するらしく、普段は内部で呼ばれているようです。

が、今回のプログラムのように、「XNAは使うけれどGameは使わないよ」というような場合にはFrameworkDispatcher.Updateメソッドを自分で呼ばなければならないのです。
これは1フレームに一回の呼び出しが推奨されています。

[2回]

ブログにSilverlight埋め込みテスト

クリックでSilverlightデモ起動

クリックするとボタンが出ます。
ボタンをクリックするとダイヤログボックスが出ます。

さてSilverlightをブログに埋め込むにはどうすればいいんでしょうね？

どうやらこんなふうにタグを使えばいいようです。

<iframe src="http://blog.cnobi.jp/v1/blog/user/118c300f2ee0ad311e5962b0167205f5/1309324795" frameborder="0" width="400" height="400" scrolling="no"></iframe>

まあ当たり前な気もします。

SilverlightApplicationDemoTestPage.htmlというのは、VisualStudioがbin\DebugやReleaseフォルダ内に作り出すhtmlファイルです。

[0回]

C#でDirectX11 SlimDXチュートリアルその14 定数バッファー

定数バッファー

ずいぶん前回と間があきましたが、SlimDXについてメモしておこうと思います。
今回は、定数バッファーです。

定数バッファーとは、CPUからGPUへのデータ転送をまとめるデータの固まりです。
どういうことでしょう？
3DCGを描くときのことを考えてください。
CPUからGPUへ、モデルの回転やライトの位置など、情報を転送しなければいけません。
そしてその転送にはオーバーヘッドがかかります。
これをいちいち別々に転送していては、オーバーヘッドが膨らむばかり。
そこでこれらを一つにまとめて一気にGPUへ転送しようということです。
そのひとつにまとめられたものを、コンスタントバッファーといいます。

定数バッファーの生成

定数バッファーは、Bufferクラスのインスタンスです。
頂点バッファやインデックスバッファと同じですね。
ただ使い方が違うのです。
そして初期化の方法も。
初期化するときには、BindFlagsにBindFlags.ConstantBufferを指定します。

private void initConstantBuffer()

{

constantBuffer = new Buffer(

GraphicsDevice,

new BufferDescription

{

//なぜかsizeof(float) * 4以上でないと例外をスローする。

SizeInBytes = sizeof(float) * 4,

BindFlags = BindFlags.ConstantBuffer,

}

);

}

ここで気をつけて欲しいのは、SizeInBytesにsizeof(float) * 4より小さな値を代入するとマズイ事になるかもしれないということです。
大してデータを使わないからと言って、もし小さな値を代入すれば、Direct3D11Exceptionをスローすることがあるので注意してください。
少なくとも私の環境ではそうでした。
すべての環境でそうであるかはわかりません。
しかし、Vector4より小さな値が禁止されているというのはおかしな話ではないでしょう。

定数バッファーの更新（CPUからGPUへのデータ転送）

定数バッファーはCPUからGPUへのデータ転送をまとめるためのバッファです。
するとデータ転送をする方法があるはずなのですが、Bufferそのものにはそんなメソッドはありません。
データ転送には、DeviceContext.UpdateSubresourceメソッドを使います。

public void UpdateSubresource(DataBox source, Resource resource, int subresource);

sourceは、GPUに転送するデータです。
resourceは転送先のGPUに存在するリソース。
subresourceはサブリソース番号です。

定数バッファをエフェクトにセット

更新した定数バッファも、少なくとも一度はエフェクトにセットしなければ描画に反映されません。
定数バッファのエフェクトへのセットには次のようにします：

effect.GetConstantBufferByName("myConstantBuffer").ConstantBuffer = constantBuffer;

effectはセットするエフェクト。
"myConstantbuffer"は、HLSLファイル中の定数バッファの名前です。
constantBufferはセットする定数バッファです。

サンプルコード

Program.cs

using SlimDX;
using SlimDX.Direct3D11;
using SlimDX.DXGI;
using SlimDX.D3DCompiler;

class Program
{
    static void Main()
    {
        using (Game game = new MyGame())
        {
            game.Run();
        }
    }
}

struct MyConstantBuffer
{
    public float OffsetX;
    public float OffsetY;
}

class MyGame : Game
{
    Effect effect;
    InputLayout vertexLayout;
    Buffer vertexBuffer;
    Buffer constantBuffer;

    protected override void Draw()
    {
        GraphicsDevice.ImmediateContext.ClearRenderTargetView(
            RenderTarget,
            new Color4(1, 0, 0, 1)
            );

        updateConstantBuffer();
        initTriangleInputAssembler();
        drawTriangle();
        
        SwapChain.Present(0, PresentFlags.None);
    }

    private void updateConstantBuffer()
    {
        double time = System.Environment.TickCount / 500d;
        MyConstantBuffer myConstantBuffer = new MyConstantBuffer
        {
            OffsetX = (float)System.Math.Sin(time) * 0.4f,
            OffsetY = (float)System.Math.Sin(time) * 0.8f
        };
        GraphicsDevice.ImmediateContext.UpdateSubresource(
            new DataBox(0, 0, new DataStream(new[] { myConstantBuffer }, true, true)),
            constantBuffer,
            0
            );
        effect.GetConstantBufferByName("myConstantBuffer").ConstantBuffer = constantBuffer;
    }

    private void initTriangleInputAssembler()
    {
        GraphicsDevice.ImmediateContext.InputAssembler.InputLayout = vertexLayout;
        GraphicsDevice.ImmediateContext.InputAssembler.SetVertexBuffers(
            0,
            new VertexBufferBinding(vertexBuffer, sizeof(float) * 3, 0)
            );
        GraphicsDevice.ImmediateContext.InputAssembler.PrimitiveTopology
            = PrimitiveTopology.TriangleList;
    }

    private void drawTriangle()
    {
        effect.GetTechniqueByIndex(0).GetPassByIndex(0).Apply(GraphicsDevice.ImmediateContext);
        GraphicsDevice.ImmediateContext.Draw(3, 0);
    }


    protected override void LoadContent()
    {
        initEffect();
        initVertexLayout();
        initVertexBuffer();
        initConstantBuffer();
    }

    private void initEffect()
    {
        using (ShaderBytecode shaderBytecode = ShaderBytecode.CompileFromFile(
            "myEffect.fx", "fx_5_0",
            ShaderFlags.None,
            EffectFlags.None
            ))
        {
            effect = new Effect(GraphicsDevice, shaderBytecode);
        }
    }

    private void initVertexLayout()
    {
        vertexLayout = new InputLayout(
            GraphicsDevice,
            effect.GetTechniqueByIndex(0).GetPassByIndex(0).Description.Signature,
            new[] { 
                    new InputElement
                    {
                        SemanticName = "SV_Position",
                        Format = Format.R32G32B32_Float
                    }
                }
            );
    }

    private void initVertexBuffer()
    {
        vertexBuffer = MyDirectXHelper.CreateVertexBuffer(
            GraphicsDevice,
            new[] {
                new SlimDX.Vector3(0, 0.5f, 0),
                new SlimDX.Vector3(0.5f, 0, 0),
                new SlimDX.Vector3(-0.5f, 0, 0),
            });
    }

    private void initConstantBuffer()
    {
        constantBuffer = new Buffer(
            GraphicsDevice,
            new BufferDescription
            {   
                //なぜかsizeof(float) * 4以上でないと例外をスローする。
                SizeInBytes = sizeof(float) * 4,  
                BindFlags = BindFlags.ConstantBuffer,
            }
            ); 
    }

    protected override void UnloadContent()
    {
        effect.Dispose();
        vertexLayout.Dispose();
        vertexBuffer.Dispose();
        constantBuffer.Dispose();
    }
}

class Game : System.Windows.Forms.Form
{
    public SlimDX.Direct3D11.Device GraphicsDevice;
    public SwapChain SwapChain;
    public RenderTargetView RenderTarget;


    public void Run()
    {
        initDevice();
        SlimDX.Windows.MessagePump.Run(this, Draw);
        disposeDevice();
    }

    private void initDevice()
    {
        MyDirectXHelper.CreateDeviceAndSwapChain(
            this, out GraphicsDevice, out SwapChain
            );

        initRenderTarget();
        initViewport();

        LoadContent();
    }

    private void initRenderTarget()
    {
        using (Texture2D backBuffer
            = SlimDX.Direct3D11.Resource.FromSwapChain<Texture2D>(SwapChain, 0)
            )
        {
            RenderTarget = new RenderTargetView(GraphicsDevice, backBuffer);
            GraphicsDevice.ImmediateContext.OutputMerger.SetTargets(RenderTarget);
        }
    }

    private void initViewport()
    {
        GraphicsDevice.ImmediateContext.Rasterizer.SetViewports(
            new Viewport
            {
                Width = ClientSize.Width,
                Height = ClientSize.Height,
            }
            );
    }

    private void disposeDevice()
    {
        UnloadContent();
        RenderTarget.Dispose();
        GraphicsDevice.Dispose();
        SwapChain.Dispose();
    }

    protected virtual void Draw() { }
    protected virtual void LoadContent() { }
    protected virtual void UnloadContent() { }
}

class MyDirectXHelper
{
    public static void CreateDeviceAndSwapChain(
        System.Windows.Forms.Form form,
        out SlimDX.Direct3D11.Device device,
        out SlimDX.DXGI.SwapChain swapChain
        )
    {
        SlimDX.Direct3D11.Device.CreateWithSwapChain(
            DriverType.Hardware,
            DeviceCreationFlags.None,
            new SwapChainDescription
            {
                BufferCount = 1,
                OutputHandle = form.Handle,
                IsWindowed = true,
                SampleDescription = new SampleDescription
                {
                    Count = 1,
                    Quality = 0
                },
                ModeDescription = new ModeDescription
                {
                    Width = form.ClientSize.Width,
                    Height = form.ClientSize.Height,
                    RefreshRate = new SlimDX.Rational(60, 1),
                    Format = Format.R8G8B8A8_UNorm
                },
                Usage = Usage.RenderTargetOutput
            },
            out device,
            out swapChain
            );
    }

    public static Buffer CreateVertexBuffer(
        SlimDX.Direct3D11.Device graphicsDevice,
        System.Array vertices
        )
    {
        using (SlimDX.DataStream vertexStream 
            = new SlimDX.DataStream(vertices, true, true))
        {
            return new Buffer(
                graphicsDevice,
                vertexStream,
                new BufferDescription
                {
                    SizeInBytes= (int)vertexStream.Length,
                    BindFlags = BindFlags.VertexBuffer,
                }
                );
        }
    }
}

myEffect.fx

cbuffer myConstantBuffer
{
	float OffsetX;
	float OffsetY;
}

float4 MyVertexShader(float4 position : SV_Position) : SV_Position
{
    return position + float4(OffsetX, OffsetY, 0, 0);
}

float4 MyPixelShader() : SV_Target
{
    return float4(1, 1, 1, 1);
}

technique10 MyTechnique
{
	pass MyPass
	{
		SetVertexShader( CompileShader( vs_5_0, MyVertexShader() ) );
		SetPixelShader( CompileShader( ps_5_0, MyPixelShader() ) );
	}
}

このプログラムは、三角形を斜めに平行移動します。

つまり定数バッファなど使わなくても出来るプログラムです。
というか大抵のことは定数バッファなど使わなくても出来るのです。

大切なのはパフォーマンスです。
変更点があるとすれば内部です。

このプログラムでは、三角形の平行移動に使うパラメーターを、定数バッファでまとめているのです。
平行移動に使うパラメーターは２つ有ります。
X方向のオフセットを表すOffsetX(float)と、Y方向のオフセットを表すOffsetY(float)です。
もし定数バッファを使わなければ、２回、CPUからGPUにデータを転送することになります。
しかしここでは定数バッファを使ってこの２つを一つにまとめているので、CPUからGPUへのデータ転送は、毎フレーム一回だけですんでいます。

[1回]