ゲームプログラミング初心者講座: プログラミング言語比較 2019年7月版ランキング（Windows）

2019年7月27日

以下の６つのプログラミング言語（ライブラリ、ゲームエンジン）別に比較を行った。
１．DirectX11(C,C++)
２．DXライブラリ(C,C++)
３．OpenGL(C,C++,nupengl)
４．Python
５．Processing
６．Unity(C#)

（１）比較条件

・Windows(GUI)アプリケーション（.exeファイルが作成可能なもの）
・ウィンドウサイズ800×600（サイズ固定）
　※OpenGL(C,C++,nupengl)はウィンドウサイズ固定の方法が見つからなかった。
・ウィンドウタイトル：Title

（２）実行ファイルサイズランキング

・実行ファイルサイズが小さい順
・.exeだけでなく実行に必要なファイルすべての合計サイズで比較

第1位：DirectX11(C,C++)

　　11KB

第2位：OpenGL(C,C++,nupengl)

　　222KB
　　※.exeファイルとfreeglut.dllの合計サイズ

第3位：DXライブラリ(C,C++)

　　4.82MB

第4位：Python

　　7.09MB

第5位：Unity(C#)

　　52.9MB
　　※フォルダ合計サイズ

第6位：Processing

　　190MB
　　※フォルダ合計サイズ

（３）ソースコードの短さランキング

・【文字数カウント】の文字数（スペース無視）の少ない順

第1位：Processing

14文字

size(800, 600);

第2位：Python

107文字

import tkinter

root = tkinter.Tk()
root.geometry("800x600")
root.title("Title")
root.resizable(0, 0)
root.mainloop()

第3位：Unity(C#)

316文字

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class NewBehaviourScript : MonoBehaviour
{
[RuntimeInitializeOnLoadMethod]
static void OnRuntimeMethodLoad()
{
Screen.SetResolution(800, 600, false, 60);

}

// Start is called before the first frame update
void Start()
{

}

// Update is called once per frame
void Update()
{

}
}

第4位：DXライブラリ(C,C++)

324文字

#include "DxLib.h"

int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nCmdShow)
{
ChangeWindowMode(TRUE);
SetMainWindowText("Title");
SetGraphMode(800, 600, 32);
if (DxLib_Init() == -1)
{
return -1;
}

while (CheckHitKey(KEY_INPUT_ESCAPE) == 0)
{
if (ProcessMessage() == -1)
{
break;
}
}

DxLib_End();
return 0;
}

第5位：OpenGL(C,C++,nupengl)

373文字

#pragma comment(linker, "/SUBSYSTEM:WINDOWS /ENTRY:mainCRTStartup")
#include <windows.h>
#include <GL/glut.h>

void display(void)
{
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitWindowSize(800, 600);
glutInitDisplayMode(GLUT_RGBA);
glutCreateWindow("Title");
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

第6位：DirectX11(C,C++)

6446文字

#pragma comment(lib,"d3d11.lib")
#include <windows.h>
#include <d3d11_1.h>
#include <directxcolors.h>

//--------------------------------------------------------------------------------------
// グローバル変数
//--------------------------------------------------------------------------------------
HINSTANCE g_hInst = nullptr;
HWND g_hWnd = nullptr;
D3D_DRIVER_TYPE g_driverType = D3D_DRIVER_TYPE_NULL;
D3D_FEATURE_LEVEL g_featureLevel = D3D_FEATURE_LEVEL_11_0;
ID3D11Device* g_pd3dDevice = nullptr;
ID3D11Device1* g_pd3dDevice1 = nullptr;
ID3D11DeviceContext* g_pImmediateContext = nullptr;
ID3D11DeviceContext1* g_pImmediateContext1 = nullptr;
IDXGISwapChain* g_pSwapChain = nullptr;
IDXGISwapChain1* g_pSwapChain1 = nullptr;
ID3D11RenderTargetView* g_pRenderTargetView = nullptr;

//--------------------------------------------------------------------------------------
// 前方宣言
//--------------------------------------------------------------------------------------
HRESULT InitWindow(HINSTANCE hInstance, int nCmdShow);
HRESULT InitDevice();
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void Render();
void CleanupDevice();

int WINAPI wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nCmdShow)
{
if (FAILED(InitWindow(hInstance, nCmdShow)))
return 0;

if (FAILED(InitDevice()))
{
CleanupDevice();
return 0;
}

// メインメッセージループ
MSG msg = { 0 };
while (WM_QUIT != msg.message)
{
if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
Render();
}
}

CleanupDevice();

return (int)msg.wParam;
}

HRESULT InitWindow(HINSTANCE hInstance, int nCmdShow)
{
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = nullptr;
wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wcex.lpszMenuName = nullptr;
wcex.lpszClassName = L"WindowClass";
wcex.hIconSm = nullptr;
if (!RegisterClassEx(&wcex))
return E_FAIL;

g_hInst = hInstance;
RECT rc = { 0, 0, 800, 600 };
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
g_hWnd = CreateWindow(L"WindowClass", L"DirectX11の初期化",
WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, nullptr, nullptr, hInstance,
nullptr);
if (!g_hWnd)
return E_FAIL;

ShowWindow(g_hWnd, nCmdShow);

return S_OK;
}

HRESULT InitDevice()
{
HRESULT hr = S_OK;

RECT rc;
GetClientRect(g_hWnd, &rc);
UINT width = rc.right - rc.left;
UINT height = rc.bottom - rc.top;

UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif

D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = ARRAYSIZE(driverTypes);

D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
UINT numFeatureLevels = ARRAYSIZE(featureLevels);

for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++)
{
g_driverType = driverTypes[driverTypeIndex];
hr = D3D11CreateDevice(nullptr, g_driverType, nullptr, createDeviceFlags, featureLevels, numFeatureLevels,
D3D11_SDK_VERSION, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext);

if (hr == E_INVALIDARG)
{
hr = D3D11CreateDevice(nullptr, g_driverType, nullptr, createDeviceFlags, &featureLevels[1], numFeatureLevels - 1,
D3D11_SDK_VERSION, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext);
}

if (SUCCEEDED(hr))
break;
}
if (FAILED(hr))
return hr;

IDXGIFactory1* dxgiFactory = nullptr;
{
IDXGIDevice* dxgiDevice = nullptr;
hr = g_pd3dDevice->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&dxgiDevice));
if (SUCCEEDED(hr))
{
IDXGIAdapter* adapter = nullptr;
hr = dxgiDevice->GetAdapter(&adapter);
if (SUCCEEDED(hr))
{
hr = adapter->GetParent(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&dxgiFactory));
adapter->Release();
}
dxgiDevice->Release();
}
}
if (FAILED(hr))
return hr;

IDXGIFactory2* dxgiFactory2 = nullptr;
hr = dxgiFactory->QueryInterface(__uuidof(IDXGIFactory2), reinterpret_cast<void**>(&dxgiFactory2));
if (dxgiFactory2)
{
hr = g_pd3dDevice->QueryInterface(__uuidof(ID3D11Device1), reinterpret_cast<void**>(&g_pd3dDevice1));
if (SUCCEEDED(hr))
{
(void)g_pImmediateContext->QueryInterface(__uuidof(ID3D11DeviceContext1), reinterpret_cast<void**>(&g_pImmediateContext1));
}

DXGI_SWAP_CHAIN_DESC1 sd = {};
sd.Width = width;
sd.Height = height;
sd.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.BufferCount = 1;

hr = dxgiFactory2->CreateSwapChainForHwnd(g_pd3dDevice, g_hWnd, &sd, nullptr, nullptr, &g_pSwapChain1);
if (SUCCEEDED(hr))
{
hr = g_pSwapChain1->QueryInterface(__uuidof(IDXGISwapChain), reinterpret_cast<void**>(&g_pSwapChain));
}

dxgiFactory2->Release();
}
else
{
DXGI_SWAP_CHAIN_DESC sd = {};
sd.BufferCount = 1;
sd.BufferDesc.Width = width;
sd.BufferDesc.Height = height;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = g_hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;

hr = dxgiFactory->CreateSwapChain(g_pd3dDevice, &sd, &g_pSwapChain);
}

dxgiFactory->MakeWindowAssociation(g_hWnd, DXGI_MWA_NO_ALT_ENTER);

dxgiFactory->Release();

if (FAILED(hr))
return hr;

ID3D11Texture2D* pBackBuffer = nullptr;
hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&pBackBuffer));
if (FAILED(hr))
return hr;

hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, nullptr, &g_pRenderTargetView);
pBackBuffer->Release();
if (FAILED(hr))
return hr;

g_pImmediateContext->OMSetRenderTargets(1, &g_pRenderTargetView, nullptr);

D3D11_VIEWPORT vp;
vp.Width = (FLOAT)width;
vp.Height = (FLOAT)height;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
g_pImmediateContext->RSSetViewports(1, &vp);

return S_OK;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;

switch (message)
{
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;

case WM_DESTROY:
PostQuitMessage(0);
break;

default:
return DefWindowProc(hWnd, message, wParam, lParam);
}

return 0;
}

void Render()
{
g_pImmediateContext->ClearRenderTargetView(g_pRenderTargetView, DirectX::Colors::Aquamarine);
g_pSwapChain->Present(0, 0);
}

void CleanupDevice()
{
if (g_pImmediateContext) g_pImmediateContext->ClearState();

if (g_pRenderTargetView) g_pRenderTargetView->Release();
if (g_pSwapChain1) g_pSwapChain1->Release();
if (g_pSwapChain) g_pSwapChain->Release();
if (g_pImmediateContext1) g_pImmediateContext1->Release();
if (g_pImmediateContext) g_pImmediateContext->Release();
if (g_pd3dDevice1) g_pd3dDevice1->Release();
if (g_pd3dDevice) g_pd3dDevice->Release();
}

（４）まとめ

・実行ファイルサイズはDirectX、OpenGLが圧倒的に小さい。
・Processingは配布には向かない。
・プログラミング言語によってコードの長さやできることが違うので、
　用途によって使い分ける。

ゲームプログラミング初心者講座

メニュー

このブログを検索

2019年7月27日土曜日

プログラミング言語比較 2019年7月版ランキング（Windows）

0 件のコメント:

コメントを投稿