2d图形旋转

已于 2022-08-30 05:50:19 修改
阅读量357 收藏
点赞数
分类专栏： diectx 文章标签： windows
于 2022-08-29 23:08:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangdaochao/article/details/126594314
版权

2d图形旋转

1.这里旋转使用数学公式:
xr = x * cos(theta) - y * sin(theta);
yr = x * sin(theta) + y * cos(theta);
2.如果以左上角为原点(0,0)，x方向向右增加,y方向向下增加的话，对于原图形旋转的100度并不等于连续20次的旋转5度的结果，可以举例对比一下。
3.memcpy对于复制对象真的很好用。
4.在这里我重画背景使用的是gdi的FillRect:
HDC hdc;
lpddsprimary->GetDC(&hdc);
FillRect(hdc, &client, (HBRUSH)GetStockObject(WHITE_BRUSH));
lpddsprimary->ReleaseDC(hdc);
该程序以左上角(0,0)为原点，支持移动、改变窗口大小重画360°图形。

#include <Windows.h>
#include <ddraw.h>
#include <math.h>

#pragma comment(lib, "ddraw.lib")
#pragma comment(lib, "dxguid.lib")

#define WINDOW_WIDTH		640
#define WINDOW_HEIGHT		480
#define SCREEN_BPP			32
#define SCREEN_WIDTH		1920
#define SCREEN_HEIGHT		1080
#define KEY_DOWN(vk_code)	(GetAsyncKeyState(vk_code) & 0x8000 ? 1 : 0)
#define KEY_UP(vk_code)		(GetAsyncKeyState(vk_code) & 0x8000 ? 0 : 1)

#define CLIP_CODE_C		0x0000
#define CLIP_CODE_N		0x0008
#define CLIP_CODE_S		0x0004
#define CLIP_CODE_E		0x0002
#define CLIP_CODE_W		0x0001

#define CLIP_CODE_NE	0x000a
#define CLIP_CODE_SE	0x0006
#define CLIP_CODE_NW	0x0009
#define CLIP_CODE_SW	0x0005

typedef struct VERTEX2DI_TYP
{
	int x, y;
}VERTEX2DI, * VERTEX2DI_PTR;

typedef struct POLYGON2D_TYP
{
	int state;
	int num_verts;
	int x0, y0;
	int xv, yv;
	LONG color;
	VERTEX2DI* vlist;
} POLYGON2D, * POLYGON2D_PTR;

HWND main_hwnd = nullptr;
RECT client;
LPDIRECTDRAW7 lpdd7 = nullptr;
LPDIRECTDRAWSURFACE7 lpddsprimary = nullptr;
LPDIRECTDRAWCLIPPER lpddclipper = nullptr;
DDSURFACEDESC2 ddsd;
int pixel;
int window_close = 0;
POLYGON2D triangles[4];
float cos_look[360];
float sin_look[360];
int theta = -5;	//旋转度数

int Game_Init(void* params = nullptr, int num_params = 0);
int Game_Main(void* params = nullptr, int num_params = 0);
int Game_Shutdown(void* params = nullptr, int num_params = 0);
int Draw_Line(int x1, int y1, int x2, int y2, LONG color, LONG* vb_start, int iPitch);
int Clip_Line(int& x1, int& y1, int& x2, int& y2);
int GetInterSectionPoint(int p_code, int& xc, int& yc, int x1, int y1, int x2, int y2, int min_clip_x, int min_clip_y, int max_clip_x, int max_clip_y);
int Draw_Clip_Line(int x1, int y1, int x2, int y2, LONG color, LONG* vb_start, int iPitch);
int Draw_Polygon2D(POLYGON2D_PTR poly, LONG* vb_strat, int iPitch);
int Rotate_Polygon2D(POLYGON2D_PTR poly, int theta);

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
	TCHAR szAppName[] = TEXT("normal window");
	MSG msg;
	WNDCLASS wndclass;


	wndclass.style = CS_VREDRAW | CS_HREDRAW;
	wndclass.lpfnWndProc = WndProc;
	wndclass.cbClsExtra = 0;
	wndclass.cbWndExtra = 0;
	wndclass.hInstance = hInstance;
	wndclass.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
	wndclass.hCursor = LoadCursor(nullptr, IDC_ARROW);
	wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	wndclass.lpszMenuName = nullptr;
	wndclass.lpszClassName = szAppName;

	if (!RegisterClass(&wndclass))
	{
		MessageBox(nullptr, TEXT("Register Class Failed"), szAppName, MB_ICONERROR);
		return 0;
	}

	client = {0, 0, WINDOW_WIDTH-1, WINDOW_HEIGHT-1};
	AdjustWindowRect(&client, WS_OVERLAPPEDWINDOW, false);

	main_hwnd = CreateWindow(
		szAppName, TEXT("normal_window"), WS_OVERLAPPEDWINDOW | WS_VISIBLE,
		CW_USEDEFAULT, CW_USEDEFAULT, client.right - client.left, client.bottom - client.top,
		nullptr, nullptr, hInstance, nullptr
	);

	Game_Init();

	while (true)
	{
		if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT)
				break;
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		Game_Main();
	}

	Game_Shutdown();

	return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	HDC hdc;
	PAINTSTRUCT ps;
	int xPos;
	int yPos;


	switch (message)
	{
	case WM_CREATE:
		//create
		return 0;
	case WM_SIZE:
		//change size
		theta = -5;
		return 0;
	case WM_MOVE:
		//move
		theta = -5;
		return 0;
	case WM_LBUTTONDOWN:
		xPos = LOWORD(lParam);
		yPos = HIWORD(lParam);
		return 0;

	case WM_PAINT:
		hdc = BeginPaint(hwnd, &ps);
		//draw
		EndPaint(hwnd, &ps);
		return 0;
	case WM_DESTROY:
		window_close = 1;
		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc(hwnd, message, wParam, lParam);
}

int Game_Init(void* params, int num_params)
{
	if (FAILED(DirectDrawCreateEx(nullptr, (LPVOID*)&lpdd7, IID_IDirectDraw7, nullptr)))
		return 0;

	lpdd7->SetCooperativeLevel(main_hwnd, DDSCL_NORMAL);

	memset(&ddsd, 0, sizeof(ddsd));
	ddsd.dwSize = sizeof(ddsd);
	ddsd.dwFlags = DDSD_CAPS;

	ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
	if (FAILED(lpdd7->CreateSurface(&ddsd, &lpddsprimary, nullptr)))
		return 0;

	//获取像素格式
	DDPIXELFORMAT ddpixelformat;
	memset(&ddpixelformat, 0, sizeof(ddpixelformat));
	ddpixelformat.dwSize = sizeof(ddpixelformat);
	lpddsprimary->GetPixelFormat(&ddpixelformat);
	pixel = ddpixelformat.dwRGBBitCount;

	if (FAILED(lpdd7->CreateClipper(0, &lpddclipper, nullptr)))
		return 0;

	if (FAILED(lpddclipper->SetHWnd(0, main_hwnd)))
		return 0;

	if (FAILED(lpddsprimary->SetClipper(lpddclipper)))
		return 0;

	//init triangles
	for (int i = 0; i < 4; i++)
	{
		triangles[i].state = 1;
		triangles[i].num_verts = 4;
		RECT rect = { 300 + i * 50, 300 + i * 50, 300 + i * 50 + 50, 300 + i * 50 + 50 };
		triangles[i].x0 = (rect.left + rect.right) / 2;
		triangles[i].y0 = (rect.top + rect.bottom) / 2;
		triangles[i].xv = triangles[i].yv = 10;
		triangles[i].color = RGB(rand() % 256, rand() % 256, rand() % 256);
		triangles[i].vlist = new VERTEX2DI[triangles[i].num_verts];
		triangles[i].vlist[0] = { rect.left, rect.top };
		triangles[i].vlist[1] = { rect.right, rect.top };
		triangles[i].vlist[2] = { rect.right, rect.bottom };
		triangles[i].vlist[3] = { rect.left, rect.bottom };
	}

	//generate the tables
	for (int ang = 0; ang < 360; ang++)
	{
		float theta = (float)ang * 3.14159 / 180;
		sin_look[ang] = sin(theta);
		cos_look[ang] = cos(theta);
	}

	return 1;
}

int Game_Main(void* params, int num_params)
{
	DDBLTFX ddbltfx;

	if (KEY_DOWN(VK_ESCAPE))
	{
		window_close = 1;
		SendMessage(main_hwnd, WM_CLOSE, 0, 0);
		return 0;
	}

	if (window_close)
		return 0;

	//GetClientRect(main_hwnd, &client);
	GetWindowRect(main_hwnd, &client);

	if (theta == -5)	//界面初始化为白色
	{
		HDC hdc;
		lpddsprimary->GetDC(&hdc);
		FillRect(hdc, &client, (HBRUSH)GetStockObject(WHITE_BRUSH));
		lpddsprimary->ReleaseDC(hdc);
	}

	memset(&ddsd, 0, sizeof(ddsd));
	ddsd.dwSize = sizeof(ddsd);
	if (FAILED(lpddsprimary->Lock(nullptr, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, nullptr)))
		return 0;

	LONG* video_buffer = (LONG*)ddsd.lpSurface;
	int ipitch = ddsd.lPitch;

	if (pixel == 32)
	{
		if (theta < 355)
		{
			theta += 5;
			if (theta == 360)
			{
				int x = 0;
			}
			//init temp_triangles
			POLYGON2D temp_triangles[4];
			memcpy(temp_triangles, triangles, sizeof(triangles));
			for (int i = 0; i < 4; i++)
			{
				temp_triangles[i].vlist = new VERTEX2DI[temp_triangles[i].num_verts];
				memcpy(temp_triangles[i].vlist, triangles[i].vlist, temp_triangles[i].num_verts * sizeof(VERTEX2DI));
			}

			for (int i = 0; i < 4; i++)
			{
				Rotate_Polygon2D(temp_triangles + i, theta);
				Draw_Polygon2D(temp_triangles + i, video_buffer, ipitch >> 2);
			}

			//destroy temp_triangles.vlist
			for (int i = 0; i < 4; i++)
				delete[] temp_triangles[i].vlist;
		}
	}

	if (FAILED(lpddsprimary->Unlock(nullptr)))
		return 0;

	//Sleep(10000);
	return 1;
}

int Game_Shutdown(void* params, int num_params)
{
	if (lpddsprimary)
	{
		lpddsprimary->Release();
		lpddsprimary = nullptr;
	}
	if (lpddclipper)
	{
		lpddclipper->Release();
		lpddclipper = nullptr;
	}
	if (lpdd7)
	{
		lpdd7->Release();
		lpdd7 = nullptr;
	}

	//destroy triangles
	for (int i = 0; i < 4; i++)
		delete[] triangles[i].vlist;

	return 1;
}

int Draw_Line(int x1, int y1, int x2, int y2, LONG color, LONG* vb_start, int iPitch)
{
	int dx = x2 - x1;
	int dy = y2 - y1;
	int inx, iny, dx2, dy2, error;

	if (dx >= 0)
		inx = 1;
	else
	{
		inx = -1;
		dx = -dx;
	}
	if (dy >= 0)
		iny = iPitch;
	else
	{
		iny = -iPitch;
		dy = -dy;
	}

	dx2 = dx << 1;
	dy2 = dy << 1;
	vb_start += x1 + y1 * iPitch;

	if (dx > dy)
	{
		error = dy2 - dx;
		for (int i = 0; i <= dx; i++)
		{
			*vb_start = color;
			if (error >= 0)
			{
				error -= dx2;
				vb_start += iny;
			}
			error += dy2;
			vb_start += inx;
		}
	}
	else
	{
		error = dx2 - dy;
		for (int i = 0; i <= dy; i++)
		{
			*vb_start = color;
			if (error >= 0)
			{
				error -= dy2;
				vb_start += inx;
			}
			error += dx2;
			vb_start += iny;
		}
	}
	return 1;
}

int Clip_Line(int& x1, int& y1, int& x2, int& y2)
{
	int min_clip_x = client.left;
	int min_clip_y = client.top;
	int max_clip_x = client.right;
	int max_clip_y = client.bottom;

	int xc1 = x1, yc1 = y1, xc2 = x2, yc2 = y2;
	int p1_code = 0, p2_code = 0;

	if (y1 < min_clip_y)
		p1_code |= CLIP_CODE_N;
	else if (y1 > max_clip_y)
		p1_code |= CLIP_CODE_S;
	if (x1 < min_clip_x)
		p1_code |= CLIP_CODE_W;
	else if (x1 > max_clip_x)
		p1_code |= CLIP_CODE_E;
	if (y2 < min_clip_y)
		p2_code |= CLIP_CODE_N;
	else if (y2 > max_clip_y)
		p2_code |= CLIP_CODE_S;
	if (x2 < min_clip_x)
		p2_code |= CLIP_CODE_W;
	else if (x2 > max_clip_x)
		p2_code |= CLIP_CODE_E;

	if (p1_code & p2_code)
		return 0;
	if (p1_code == 0 && p2_code == 0)
		return 1;

	int iSpStatus1 = GetInterSectionPoint(p1_code, xc1, yc1, x1, y1, x2, y2, min_clip_x, min_clip_y, max_clip_x, max_clip_y);
	int iSpStatus2 = GetInterSectionPoint(p2_code, xc2, yc2, x1, y1, x2, y2, min_clip_x, min_clip_y, max_clip_x, max_clip_y);

	if (!(iSpStatus1 | iSpStatus2))
		return  0;

	x1 = xc1;
	y1 = yc1;
	x2 = xc2;
	y2 = yc2;

	return 1;
}

int GetInterSectionPoint(int p_code, int& xc, int& yc, int x1, int y1, int x2, int y2, int min_clip_x, int min_clip_y, int max_clip_x, int max_clip_y)
{
	switch (p_code)
	{
	case CLIP_CODE_N:
		yc = min_clip_y;
		xc = x1 + (min_clip_y - y1) * (x2 - x1) / (y2 - y1);
		break;
	case CLIP_CODE_S:
		yc = max_clip_y;
		xc = x1 + (max_clip_y - y1) * (x2 - x1) / (y2 - y1);
		break;
	case CLIP_CODE_W:
		xc = min_clip_x;
		yc = y1 + (min_clip_x - x1) * (y2 - y1) / (x2 - x1);
		break;
	case CLIP_CODE_E:
		xc = max_clip_x;
		yc = y1 + (max_clip_x - x1) * (y2 - y1) / (x2 - x1);
		break;
	case CLIP_CODE_NW:
		yc = min_clip_y;
		xc = x1 + (min_clip_y - y1) * (x2 - x1) / (y2 - y1);
		if (xc < min_clip_x)
		{
			xc = min_clip_x;
			yc = y1 + (min_clip_x - x1) * (y2 - y1) / (x2 - x1);
		}
		break;
	case CLIP_CODE_SW:
		yc = max_clip_y;
		xc = x1 + (max_clip_y - y1) * (x2 - x1) / (y2 - y1);
		if (xc < min_clip_x)
		{
			xc = min_clip_x;
			yc = y1 + (min_clip_x - x1) * (y2 - y1) / (x2 - x1);
		}
		break;
	case CLIP_CODE_NE:
		yc = min_clip_y;
		xc = x1 + (min_clip_y - y1) * (x2 - x1) / (y2 - y1);
		if (xc > max_clip_x)
		{
			xc = max_clip_x;
			yc = y1 + (max_clip_x - x1) * (y2 - y1) / (x2 - x1);
		}
		break;
	case CLIP_CODE_SE:
		yc = max_clip_y;
		xc = x1 + (max_clip_y - y1) * (x2 - x1) / (y2 - y1);
		if (xc > max_clip_x)
		{
			xc = max_clip_x;
			yc = y1 + (max_clip_x - x1) * (y2 - y1) / (x2 - x1);
		}
		break;
	}
	if (xc < min_clip_x || xc > max_clip_x || yc < min_clip_y || yc > max_clip_y)
		return 0;

	return 1;
}

int Draw_Clip_Line(int x1, int y1, int x2, int y2, LONG color, LONG* vb_start, int iPitch)
{
	int iDcStatus = Clip_Line(x1, y1, x2, y2);
	if (!iDcStatus)
		return 0;
	Draw_Line(x1, y1, x2, y2, color, vb_start, iPitch);
	return 1;
}

int Draw_Polygon2D(POLYGON2D_PTR poly, LONG* vb_strat, int iPitch)
{
	if (poly->state)
	{
		for (int i = 0; i < poly->num_verts - 1; i++)
		{
			Draw_Clip_Line(poly->vlist[i].x, poly->vlist[i].y, poly->vlist[i + 1].x, poly->vlist[i + 1].y, poly->color, vb_strat, iPitch);
		}
		Draw_Clip_Line(poly->vlist[poly->num_verts - 1].x, poly->vlist[poly->num_verts - 1].y, poly->vlist[0].x, poly->vlist[0].y, poly->color, vb_strat, iPitch);
		return 1;
	}
	return 0;
}

int Rotate_Polygon2D(POLYGON2D_PTR poly, int theta)
{
	if (!poly)
		return 0;
	for (int curr_vert = 0; curr_vert < poly->num_verts; curr_vert++)
	{
		float xr = poly->vlist[curr_vert].x * cos_look[theta] - poly->vlist[curr_vert].y * sin_look[theta];
		float yr = poly->vlist[curr_vert].x * sin_look[theta] + poly->vlist[curr_vert].y * cos_look[theta];
		poly->vlist[curr_vert].x = xr;
		poly->vlist[curr_vert].y = yr;
	}
	return 1;
}

下面是效果图：
在这里插入图片描述在这里插入图片描述
在这里插入图片描述

明天过后mm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2d平移、缩放、旋转、倾斜、多属性值
YY的博客
10-02 1529
属性：transform-origin：center；transform：scale（1.5）；transform：translate（100px，100px）；transform：skew（）；
2D图像中点的旋转
ubunfans的专栏
05-12 2578
点可以看做以原点为起点的向量，而向量是用其在X轴Y轴的投影来表示，如图所示： 向量p可以表示为（x0, y0） 用公式表示就是内积 如果要让向量绕原点逆时针旋转θ 如上图所示 换一种思路考虑，把坐标轴以原点为中心顺时针旋转，在这种情况下就是让坐标轴顺时针旋转θ 为了方便我们，坐标轴用单位
关于2D旋转基础总结
m0_60273757的博客
08-09 292
移动 translate 格式：transform:translate(x,y); X轴和Y轴同时移动 （合并书写，可分开书写） transform:translateX(n); 沿X轴移动 transform:translateY(n); 沿Y轴移动 举例：transform:translate(100px,50%); 沿X轴正方向移动100像素同时沿Y轴正方向移动盒子的50% transform:translateX(-100px);
2D转换（移动：translate，旋转：rotate，缩放：scale，2D转换综合写法）
shy的博客
04-21 956
2D转换 transform是CSS3中最具有颠覆性的特性之一，可以实现元素的位移、旋转、缩放等效果 移动：translate 旋转：rotate 缩放：scale 2D转换是改变标签在二维平面上位置和形状的一种技术 移动：translate 2D移动是2D转换中的一种功能，可以改变元素的位置，类似定位 translate不会影响到其他元素的位置 translate中的百分比单位是相对于自身元素的 对行内标签没有效果 transform: translate(x,y);或者分开写
处理2D图像和纹理——旋转，缩放和镜像一张图像
weixin_30646315的博客
11-16 141
问题 在将图像绘制到屏幕前你想对它进行旋转，缩放或镜像操作。 解决方案 SpriteBatch 类（见前一个教程）的Draw方法的不同重载可以让你很简单地进行上述操作。 工作原理 旋转/缩放/镜像一个图像 SpriteBatch.Draw方法有几个有用的重载。下面是最复杂的一个重载方法，参数会在后面加以讨论： public void Draw (Texture2D texture...
ARM 图片任意角度旋转效果——liuwei 同志写的系统，很强大
lqxandroid2012的专栏
11-12 1832
硬件平台: S3C2440 + 4.3寸TFT（480x272） 旋转算法： void RotateImage(HDC hdc,int x,int y,HIMG hImg,int angle) { S32 radians; S32 cos_a,sin_a,cos_ay,sin_ay; S32 point1x,point1y,point2x,point2y,point3x,po
XUANZHUAN.rar_图形旋转
最新发布
09-23
在计算机图形学中，图形旋转是一项基础且重要的技术，它被广泛应用于各种应用程序，如游戏开发、图像处理、用户界面设计等。标题“XUANZHUAN.rar_图形旋转”提示我们，这个压缩包包含的是一些关于图形旋转的源代码，...
Java绘制2D图形
10-31
Java绘制2D图形是Java GUI编程中的一个重要部分，它允许开发者在屏幕上创建各种复杂的视觉元素。在本项目中，我们看到一个实现，它在构造的面板上随机绘制了20个图形，这些图形是由`MyShape`抽象类及其多个子类来...
QT Opengl 图形旋转
04-06
QT OpenGL 图形旋转是计算机图形学中的一个常见应用，它涉及到使用QT框架和OpenGL库来创建动态、交互式的3D图形。在这个小实例中，我们将会深入探讨如何在QT环境中结合OpenGL实现图形的旋转效果。 首先，QT是一个跨...
2D图片旋转
05-05
在计算机图形学中，2D图片的旋转是一个基础但重要的概念，它广泛应用于游戏开发、用户界面设计、图像处理等领域。本练习主要关注如何在2D环境中实现图片的旋转，并结合按钮元素进行交互式2D旋转。我们将探讨旋转的...
usdng.zip_2D图形编程_matlab_
08-11
标题中的"usdng.zip_2D图形编程_matlab_"表明这是一个使用MATLAB进行2D图形编程的项目，可能是一个用于转子动力学计算的软件。MATLAB是一种强大的数学计算和数据分析环境，它广泛应用于工程、科学和经济领域。2D图形...
Unity中对一张2D图片进行旋转
LRanger_1010的博客
09-13 1万+
这段时间项目中碰到要让用户选择本地相册或调用手机摄像头拍摄后的图片进行简单的旋转并上传到服务器的需求，关于打开本地相册和调用摄像头的部分这里先略过，这篇文章主要讲讲当拿到本地的图片后怎样对图片进行简单的旋转。 首先，因为要上传到服务器，所以这里对图片的旋转必须对Texture本身进行操作，故我用到了Texture2D类里的方法：GetPixel和SetPixel，GetPixel用来获取坐标为（
html与css实现2D效果旋转
dayexiaofan的博客
05-23 2092
1、盾牌 <!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8"> <title></title> <link rel="shortcut icon" href="bkq.ico" type="image/x-icon"/&gt...
2D、3D旋转矩阵
haibo
07-22 6910
2D、3D旋转矩阵 旋转矩阵（Rotation matrix）是在乘以一个向量的时候有改变向量的方向但不改变大小的效果的矩阵。旋转矩阵不包括反演，它可以把右手坐标系改变成左手坐标系或反之。所有旋转加上反演形成了正交矩阵的集合。旋转可分为主动旋转与被动旋转。主动旋转是指将向量逆时针围绕旋转轴所做出的旋转。被动旋转是对坐标轴本身进行的逆时针旋转，它相当于主动旋转的逆操作。
Unity2D：物体旋转方法
lamperouge_conan的博客
11-17 8033
Unity2D：物体旋转方法transform.Rotate()transform.rotation transform.Rotate() float zAngle; zAngle += 10f*Time.deltaTime; transform.Rotate(0, 0, zAngle, Space.Self); zAngle：旋转角度 例：30度 zAngle=30f transform.rotation float zAngle; zAngle += 10f*Time.deltaTime; trans
2D动画效果变换中的旋转和平移效果
taotaoaiqinqin的博客
05-18 925
2D变换中的旋转和平移效果 #mydiv{ width: 200px; height: 200px; background-color: red; margin:...
html：对于2d转换的初步认知+小盒子旋转的hover效果实现
astar2022的博客
07-19 1026
今日份更新，谢谢大家支持，我会更加努力的。
【Unity3d基础】Unity3d 中如何旋转一张2D图片到指定角度
热门推荐
coffeecato的个人博客
07-06 1万+
引言 近日在开发项目中，遇到一个这样的需求：将炮弹旋转至开火方到受击方所成的角度上，简言之就是将一枚炮弹旋转到开或者到敌人的方向上。 如何旋转2D贴图？ 查阅了很多资料，都是关于四元数，欧拉角的问题。有点杀鸡焉用牛刀的意味，于是自己摸索着利用已有的接口用一种简单的方法实现。（注意，我的需求存在于2D场景内） 用到的接口 Vector3.Angle
Java2D图形编程指南
本书详细介绍了Java2D图形编程的相关知识，适合对Java图形绘制感兴趣的开发者。Java2D是一个强大的图形处理框架，它提供了丰富的功能，用于在Java应用程序中创建高质量的2D图像、文本和图形。 1. **Java2D是什么？*...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值