path: root/source/tests/win32/01-window/03_sub_menu.cpp

#include "config.h"
#if _run_app == _sub_menu

#include <asura-utils/io/file_system.h>
#include <asura-utils/io/data_buffer.h>
#include <asura-core/graphics/image.h>
#include <asura-core/graphics/shader.h>
#include <asura-core/image/image_data.h>
#include <SDL2/SDL.h>
#include <string>

using namespace std;
using namespace AEIO;
using namespace AEGraphics;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void AddMenus(HWND);

#define IDM_FILE_NEW 1
#define IDM_FILE_IMPORT 2

#define IDM_IMPORT_MAIL 11

#define IDM_ASSET 20

HWND wnd;

AEMath::Recti viewport;


/*
shader �����
* MVP matrix
* position 
* UV
*		UV_0
*		UV_1
*		UV_2
*		UV_n
* ��framework���涨�壬���DZ༭������Ҫ����Ϊ�༭����Ⱦ�������ͼƬ��Ⱦ��
* Asura Shader Semantics.
*/
string shader_frame = R"(
// ��������
in vec2 asura_position;
in vec4 asura_color;
// asura_texcoord(n)
in vec2 asura_texcoord0;
in vec2 asura_texcoord1;
in vec2 asura_texcoord2;
in vec2 asura_texcoord3;
in vec2 asura_texcoord4;

// uniform����
uniform mat4 asura_projection_matrix; 
uniform mat4 asura_model_matrix;
uniform mat4 asura_view_matrix;

uniform mat4 asura_draw_color;

uniform int asura_layer; // 0~10000��������Ȳ���

uniform vec2 asura_time; // ���뵱ǰ������ʱ���ǰ����֡�ļ��

)";

string vert = R"(

in vec2 vertex;
in vec2 vertUVs; 

uniform mat4 projMatrix; 
uniform mat4 modelMatrix; 
uniform mat4 viewMatrix; 

out vec2 texCoord; 

void main() 
{
	texCoord = vertUVs; 
	gl_Position = projMatrix * viewMatrix * modelMatrix * vec4(vertex, 1, 1); 
}
)";

string frag = R"(
in vec2 texCoord; 
uniform sampler2D img;
uniform sampler2D img2;
void main() 
{
	gl_FragColor =  texture2D(img, texCoord);
}
)";

Shader* shader;
GPUBuffer* vb;

struct Vert
{
	float x, y; // coord
	float s, t; // uv
};

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR lpCmdLine, int nCmdShow) 
{

	AEIO::Filesystem::Get()->Init("D:\Asura\bin\win64");
	MSG  msg;
	WNDCLASSW wc = { 0 };
	wc.lpszClassName = L"Submenu";
	wc.hInstance = hInstance;
	wc.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
	wc.lpfnWndProc = WndProc;
	wc.hCursor = LoadCursor(0, IDC_ARROW);
	RegisterClassW(&wc);

	wnd = CreateWindowW(wc.lpszClassName, L"Asura v0.1",
		WS_OVERLAPPEDWINDOW | WS_VISIBLE,
		200, 200, 550, 450, 0, 0, hInstance, 0);

	while (GetMessage(&msg, NULL, 0, 0)) {

		TranslateMessage(&msg);
		DispatchMessage(&msg);

		::Sleep(1);
	}

	return (int)msg.wParam;
}
HDC hdc;
HGLRC glc;
HGLRC glc2;
static PAINTSTRUCT ps;
HBRUSH hBrush;
HBRUSH hOldBrush;
HPEN hPen;
HPEN hOldPen;
PIXELFORMATDESCRIPTOR pfd;
int pf;
File* file;
File* file2;
DataBuffer db(102400);
AEIO::Filesystem* fs;
ImageData* imgdata = new ImageData();
Image* img;
GLint tex;
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg,
	WPARAM wParam, LPARAM lParam) {

	switch (msg) {

	case WM_SIZE: 
	{
		if (gl.Inited())
		{
			RECT rect;
			GetWindowRect(hwnd, &rect);
			viewport.Set(0, 0, rect.right - rect.left, rect.bottom - rect.top);
			gl.SetViewport(viewport);
		}
	}
	case WM_PAINT:
		if (!gl.Inited())
			break;
		glEnable(GL_BLEND);
		glEnable(GL_DEPTH_TEST);
		//hdc = GetDC(hwnd);
		//glc = wglCreateContext(hdc);
		glClearColor(0.16, 0.16, 0.16, 1);
		glColor4f(0.219, 0.219, 0.219, 1);
		//glRectf(-0.5f, -0.5f, 0.5f, 0.5f);
		glColor4f(1, 1, 1, 1);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		tex = img->GetGLTexture();

		glBindTexture(GL_TEXTURE_2D, tex);    //��������

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);      //S��������ͼ
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);      //T��������ͼ
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);       //�Ŵ��������˷�ʽ
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);       //��С�������˷�ʽ

		{
			int uvAttribLoc = shader->GetAttributeLocation("vertUVs");
			int vertAttribLoc = shader->GetAttributeLocation("vertex");
			int imgLoc = shader->GetUniformLocation("img");
			int img2Loc = shader->GetUniformLocation("img2");
			int projmat = shader->GetUniformLocation("projMatrix");
			int mmat = shader->GetUniformLocation("modelMatrix");
			int vmat = shader->GetUniformLocation("viewMatrix");
			int code = gl.GetError();
			gl.UseShader(shader);
			shader->SetUniformTexture(imgLoc, *img);
			shader->SetUniformTexture(img2Loc, *img);
			gl.SetMatrixMode(MATRIX_MODE_PROJECTION);
			gl.PushMatrix();
			gl.LoadIdentity();
			gl.Ortho(0, viewport.w, viewport.h, 0, -1, 1);
			shader->SetUniformMatrix44(projmat, gl.GetMatrix(MATRIX_MODE_PROJECTION));
			gl.PopMatrix();
			gl.SetMatrixMode(MATRIX_MODE_MODEL);
			gl.LoadIdentity(); 
			gl.Translate(100, 10);
			shader->SetUniformMatrix44(mmat, gl.GetMatrix(MATRIX_MODE_MODEL));
			shader->SetUniformMatrix44(vmat, gl.GetMatrix(MATRIX_MODE_VIEW));
			vb->Bind();
			glVertexAttribPointer(vertAttribLoc, 2, GL_FLOAT, GL_FALSE, sizeof(Vert), 0);
			glVertexAttribPointer(uvAttribLoc, 2, GL_FLOAT, GL_FALSE, sizeof(Vert), (const void*)(2 * sizeof(float)));
			vb->UnBind();
			glEnableVertexAttribArray(vertAttribLoc);
			glEnableVertexAttribArray(uvAttribLoc);
			glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
			glDisableVertexAttribArray(vertAttribLoc);
			glDisableVertexAttribArray(uvAttribLoc);
			gl.UnuseShader();
		}
		glFlush();
		BeginPaint(hwnd, &ps); EndPaint(hwnd, &ps);
		UpdateWindow(hwnd);
		break;
	case WM_CREATE:
		AddMenus(hwnd);

		hdc = GetDC(hwnd);
		memset(&pfd, 0, sizeof(pfd));
		pfd.nSize = sizeof(pfd);
		pfd.nVersion = 1;
		pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
		pfd.iPixelType = PFD_TYPE_RGBA;
		pfd.cColorBits = 32;

		pf = ChoosePixelFormat(hdc, &pfd);
		SetPixelFormat(hdc, pf, &pfd);
		DescribePixelFormat(hdc, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
		//ReleaseDC(hwnd, hdc);
		//glc = wglCreateContext(hdc);
		glc = wglCreateContext(hdc);

		// ͼƬ����
		fs = AEIO::Filesystem::Get();
		fs->Mount(".", "root");
		file = new File("root/img.jpg");
		file->Open(File::FILE_MODE_READ);
		file->ReadAll(&db);
		
		wglMakeCurrent(hdc, glc);

		RECT rect;
		GetWindowRect(hwnd, &rect);
		viewport.Set(0, 0, rect.right - rect.left, rect.bottom - rect.top);
		if (!gl.Init(viewport))
			return 0;

		imgdata->Decode(db);
		img = new Image();
		img->Load(imgdata);
		wglMakeCurrent(hdc, glc);

		file2 = new File("root/img.png");
		file2->Open(File::FILE_MODE_READ);
		file2->ReadAll(&db);
		imgdata->Decode(db);
		img->Load(imgdata, {50, 100});
		imgdata->Release();

		// shader
		shader = new Shader();
		shader->Load(vert, frag);
		{
			int w = img->GetWidth(); 
			int h = img->GetHeight();
			Vert v[] = {
				{ 0, 0, 0, 0 },
				{ 0, h, 0, 1 }, 
				{ w, 0, 1, 0 },
				{ w, h, 1, 1 },
			};
			vb = new GPUBuffer(BUFFER_TYPE_VERTEX, BUFFER_USAGE_STATIC, sizeof(v));
			vb->Fill(v, sizeof(v));
		};

		break;

	case WM_COMMAND:

		switch (LOWORD(wParam)) {

		case IDM_FILE_NEW:
			MessageBoxW(wnd, L"New file selected",
				L"Information", MB_OK);
			break;

		case IDM_IMPORT_MAIL:
			MessageBoxW(NULL, L"Import mail selected",
				L"Information", MB_OK);
		}

		break;

	case WM_DESTROY:

		PostQuitMessage(0);
		break;

	}
	
	return DefWindowProcW(hwnd, msg, wParam, lParam);
}

void AddMenus(HWND hwnd) {

	HMENU hMenubar = CreateMenu();
	HMENU hMenu = CreateMenu();
	HMENU hSubMenu = CreatePopupMenu();
	HMENU asserMenu = CreateMenu();

	AppendMenuW(hMenu, MF_STRING, IDM_FILE_NEW, L"&New");

	AppendMenuW(asserMenu, MF_STRING, IDM_ASSET, L"Import &mail &assets");
	AppendMenuW(hSubMenu, MF_STRING | MF_POPUP, (UINT_PTR)asserMenu, L"Import &mail");
	AppendMenuW(hMenu, MF_STRING | MF_POPUP, (UINT_PTR)hSubMenu, L"&Import");

	AppendMenuW(hMenubar, MF_POPUP, (UINT_PTR)hMenu, L"&File");

	SetMenu(hwnd, hMenubar);
}

#endif // _run_app == _sub_menu