一个简单的基于OpenGL的Lua的游戏引擎的实例

最新推荐文章于 2024-04-11 09:41:31 发布
最新推荐文章于 2024-04-11 09:41:31 发布
阅读量6.2k 收藏 3
点赞数 1
分类专栏： C FreeImage 游戏开发 Lua OpenGL 文章标签： lua 引擎 游戏 image keyboard blend
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yellow_Bug/article/details/6591124
版权
C 同时被 3 个专栏收录
6 篇文章 0 订阅
订阅专栏
OpenGL
4 篇文章 0 订阅
订阅专栏
Lua
3 篇文章 0 订阅
订阅专栏

学习了几天Lua，今天突然想为Lua写一个简单的游戏引擎方便使用Lua单独的开发游戏，下面是一个基本的代码(很简单), Lua的代码也测试通过了但还不完整，稍候再发上来

代码如下:

#define PENQ_LUAGAME

#include <string.h>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

#include <lua/lua.h>
#include <lua/lauxlib.h>
#include <lua/lualib.h>

#include "FreeImage.h"


enum 
{
	LGME_MOVE = 0x00000001, 
	LGME_DOWN = 0x00000002,
	LGME_DOWNMOVE = 0x00000004,
	LGME_UP = 0x00000008,
	LGME_ENTRY = 0x00000010,
	LGME_LEAVE = 0x00000020
};

struct LGMain
{
	lua_State *		L;
	GLint			w;
	GLint			h;
	GLfloat			zoom;
	GLuint			mouse_event;
	GLuint			key_event;
}G_Main = {NULL,0, 0, 0.0f, 0, 0};


struct LGImage
{
	GLint	width;
	GLint	height;
	GLuint 	texture;
	GLint	has_alpha_channel;
};
typedef struct LGImage LGImage;


typedef struct 
{
	int				w;
	int 			h;
	unsigned char	*buf;
	GLint			has_alpha_channel;
}GLBITMAP;





GLBITMAP * FIBitmap2GLBitmap(FIBITMAP *fibmp)
{
	int i, j, k;
	int pitch = FreeImage_GetPitch(fibmp);
	unsigned char *bits = FreeImage_GetBits(fibmp);
	int bpp = FreeImage_GetBPP(fibmp);
	GLBITMAP *glbmp = (GLBITMAP *)malloc(sizeof(GLBITMAP));	
	RGBQUAD *palette = NULL;

	if ( !glbmp ) return NULL;
	
	glbmp->has_alpha_channel = 0;
	glbmp->w = FreeImage_GetWidth(fibmp);
	glbmp->h = FreeImage_GetHeight(fibmp);		

	switch ( bpp ) {
	case 8:
		if ( !(palette = FreeImage_GetPalette(fibmp)) ) return NULL; 
		if ( !(glbmp->buf = (unsigned char *)malloc(glbmp->w*glbmp->h*3)) ) return NULL;
		for ( i = 0; i < glbmp->h; ++i ) {
			for ( j = 0; j < glbmp->w; ++j ) {
				k = bits[i*pitch+j];
				glbmp->buf[(i*glbmp->w+j)*3+0] = palette[k].rgbRed;
				glbmp->buf[(i*glbmp->w+j)*3+1] = palette[k].rgbGreen;
				glbmp->buf[(i*glbmp->w+j)*3+2] = palette[k].rgbBlue;
			}
		}
		break;
	case 24:
		if ( !(glbmp->buf = (unsigned char *)malloc(glbmp->w*glbmp->h*3)) ) return NULL;
		for ( i = 0; i < glbmp->h; ++i ) {
			for ( j = 0; j < glbmp->w; ++j ) {
				glbmp->buf[(i*glbmp->w+j)*3+0] = bits[i*pitch+j*3+2];
				glbmp->buf[(i*glbmp->w+j)*3+1] = bits[i*pitch+j*3+1];
				glbmp->buf[(i*glbmp->w+j)*3+2] = bits[i*pitch+j*3+0];
			}
		}
		break;
	case 32:
		if ( !(glbmp->buf = (unsigned char *)malloc(glbmp->w*glbmp->h*4)) ) return NULL;
		glbmp->has_alpha_channel = 1;
		for ( i = 0; i < glbmp->h; ++i ) {
			for ( j = 0; j < glbmp->w; ++j ) {
				glbmp->buf[(i*glbmp->w+j)*4+0] = bits[i*pitch+j*4+2];
				glbmp->buf[(i*glbmp->w+j)*4+1] = bits[i*pitch+j*4+1];
				glbmp->buf[(i*glbmp->w+j)*4+2] = bits[i*pitch+j*4+0];
				glbmp->buf[(i*glbmp->w+j)*4+3] = bits[i*pitch+j*4+3];
			}
		}
		break;
	default: return NULL;	
	}

	return glbmp;
}

void FreeGLBitmap(GLBITMAP *glbmp)
{
	if ( glbmp ) {
		if ( glbmp->buf ) free(glbmp->buf);
		free(glbmp);
	}
}

LGImage * LoadLGImage(const char *filename)
{
	FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
	FIBITMAP *bitmap = NULL;
	GLBITMAP *glbmp = NULL;
	LGImage *image = NULL;

	fif = FreeImage_GetFileType(filename, 0);
	if ( FIF_UNKNOWN == fif ) {
		fif = FreeImage_GetFIFFromFilename(filename);
		if ( FIF_UNKNOWN == fif )
			return 0;	
	}
	if ( FreeImage_FIFSupportsReading(fif) ) 
		bitmap = FreeImage_Load(fif, filename, 0);
	
	if ( !bitmap ) 
		return 0;

	if ( !(glbmp = FIBitmap2GLBitmap(bitmap)) ) {
		FreeImage_Unload(bitmap);
		return 0;
	}

	if ( !(image = (LGImage *)malloc(sizeof(LGImage))) ) {
		FreeGLBitmap(glbmp);
		FreeImage_Unload(bitmap);
		return 0;
	}

	image->width = glbmp->w;
	image->height = glbmp->h;
	image->has_alpha_channel = glbmp->has_alpha_channel;

	glGenTextures(1, &image->texture);
	glBindTexture(GL_TEXTURE_2D, image->texture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	if ( glbmp->has_alpha_channel )
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, glbmp->w, glbmp->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, glbmp->buf);
	else
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, glbmp->w, glbmp->h, 0, GL_RGB, GL_UNSIGNED_BYTE, glbmp->buf);
	
	FreeGLBitmap(glbmp);
	FreeImage_Unload(bitmap);

	return image;
}




static void init_gl()
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}


static void reshape(GLint w, GLint h)
{
	if ( 0 == h ) h = 1;
	G_Main.w = w;
	G_Main.h = h;
	G_Main.zoom = (GLfloat)(w > h ? h : w);
	glViewport(0, 0, w, h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0f, (GLfloat)w/(GLfloat)h, 0.1f, G_Main.zoom);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	
	if ( G_Main.L ) {
		lua_getglobal(G_Main.L, "LuaGame_Reshape");
		lua_pushnumber(G_Main.L, w);
		lua_pushnumber(G_Main.L, h);
		lua_pcall(G_Main.L, 2, 0, 0);	
	}
}

static void display()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glLoadIdentity();
	glTranslatef(-(GLfloat)(G_Main.w>>1), -(GLfloat)(G_Main.h>>1), -G_Main.zoom);

	if ( G_Main.L ) {
		lua_getglobal(G_Main.L, "LuaGame_Display");
		lua_pcall(G_Main.L, 0, 0, 0);
	}

	glutSwapBuffers();
}

static void mouse(int button, int state, int x, int y)
{
	if ( GLUT_DOWN == state ) {
		if ( G_Main.mouse_event & LGME_DOWN ) {
			if ( G_Main.L ) {
				lua_getglobal(G_Main.L, "LuaGame_MouseDown");
				lua_pushnumber(G_Main.L, button);
				lua_pushnumber(G_Main.L, x);	
				lua_pushnumber(G_Main.L, y);
				lua_pcall(G_Main.L, 3, 0, 0);	
			}		
		}	
	} else if ( GLUT_UP == state ) {
		if ( G_Main.mouse_event & LGME_UP ) {
			if ( G_Main.L ) {
				lua_getglobal(G_Main.L, "LuaGame_MouseUp");
				lua_pushnumber(G_Main.L, button);
				lua_pushnumber(G_Main.L, x);	
				lua_pushnumber(G_Main.L, y);
				lua_pcall(G_Main.L, 3, 0, 0);	
			}		
		}
	}
}

static void mouse_move(int x, int y)
{
	if ( G_Main.mouse_event & LGME_MOVE ) {
		if ( G_Main.L ) {
			lua_getglobal(G_Main.L, "LuaGame_MouseMove");
			lua_pushnumber(G_Main.L, x);	
			lua_pushnumber(G_Main.L, y);
			lua_pcall(G_Main.L, 2, 0, 0);	
		}
	}
}

static void mouse_down_move(int x, int y)
{
	if ( G_Main.mouse_event & LGME_DOWNMOVE ) {
		if ( G_Main.L ) {
			lua_getglobal(G_Main.L, "LuaGame_MouseDownMove");
			lua_pushnumber(G_Main.L, x);	
			lua_pushnumber(G_Main.L, y);
			lua_pcall(G_Main.L, 2, 0, 0);		
		}
	}
}

static void mouse_foucs(int state)
{
	if ( GLUT_LEFT == state ) {
		if ( G_Main.mouse_event & LGME_LEAVE ) {
			if ( G_Main.L ) {
				lua_getglobal(G_Main.L, "LuaGame_MouseLeave");
				lua_pcall(G_Main.L, 0, 0, 0);
			}
		}	
	} else if ( GLUT_ENTERED == state ) {
		if ( G_Main.mouse_event & LGME_ENTRY ) {
			if ( G_Main.L ) {
				lua_getglobal(G_Main.L, "LuaGame_MouseEntry");
				lua_pcall(G_Main.L, 0, 0, 0);
			}
		}
	}
}

static void keyboard(unsigned char key, int x, int y)
{
	if ( G_Main.key_event ) {
		if ( G_Main.L ) {
			lua_getglobal(G_Main.L, "LuaGame_Keyboard");
			lua_pushnumber(G_Main.L, key);
			lua_pushnumber(G_Main.L, x);
			lua_pushnumber(G_Main.L, y);
			lua_pcall(G_Main.L, 3, 0, 0);
		}
	}
}






/*
	$@@ 引擎初始化
	$@ 返回值: 成功true, 否则false
*/
static int LuaGame_Init(lua_State *L)
{
	int argc = 1;
	char *argv[1] = {"LuaGame"};

#if defined(FREEIMAGE_LIB)
	FreeImage_Initialise(0);
#endif

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	lua_pushboolean(L, 1);
	return 1;
}


/*
	$@@ 创建窗体(5个参数)
	$@ 第一个参数: 窗体名
	$@ 第二个参数: 窗体初始位置的x坐标
	$@ 第三个参数: 窗体初始位置的y坐标
	$@ 第四个参数: 窗体的宽
	$@ 第五个参数: 窗体的高
	$@ 返回值: 成功true, 否则false
*/
static int LuaGame_CreateWindow(lua_State *L)
{
	const char *caption = luaL_checkstring(L, 1);
	int x = luaL_checknumber(L, 2);
	int y = luaL_checknumber(L, 3);
	int w = luaL_checknumber(L, 4);
	int h = luaL_checknumber(L, 5);

	glutInitWindowPosition(x, y);
	glutInitWindowSize(w, h);
	
	if ( glutCreateWindow(caption) ) {
		init_gl();
	
		glutMouseFunc(mouse);
		glutMotionFunc(mouse_down_move);
		glutPassiveMotionFunc(mouse_move);
		glutEntryFunc(mouse_foucs);
		glutKeyboardFunc(keyboard);
		glutReshapeFunc(reshape);
		glutDisplayFunc(display);
		glutIdleFunc(display);

		lua_pushboolean(L, 1);
	} else
		lua_pushboolean(L, 0);

	return 1;
}



/*
	$@@ 开启鼠标移动监听事件
*/
static int LuaGame_SetMouseMove(lua_State *L)
{
	G_Main.mouse_event |= LGME_MOVE;
	return 0;
}


/*
	$@@ 开启鼠标按下监听事件
*/
static int LuaGame_SetMouseDown(lua_State *L)
{
	G_Main.mouse_event |= LGME_DOWN;
	return 0;
}

/*
	$@@ 开启鼠标按下时移动监听事件
*/
static int LuaGame_SetMouseDownMove(lua_State *L)
{
	G_Main.mouse_event |= LGME_DOWNMOVE;
	return 0;
}


/*
	$@@ 开启鼠标弹起监听事件
*/
static int LuaGame_SetMouseUp(lua_State *L)
{
	G_Main.mouse_event |= LGME_UP;
	return 0;
}

/*
	$@@ 开启鼠标进入监听事件
*/
static int LuaGame_SetMouseEntry(lua_State *L)
{
	G_Main.mouse_event |= LGME_ENTRY;
	return 0;
}


/*
	$@@ 开启鼠标离开监听事件
*/
static int LuaGame_SetMouseLeave(lua_State *L)
{
	G_Main.mouse_event |= LGME_LEAVE;
	return 0;
}



/*
	$@@ 设置键盘监听事件
*/
static int LuaGame_SetKeyboard(lua_State *L)
{
	G_Main.key_event = 1;
	return 0;
}


static int LuaGame_CreateImage(lua_State *L)
{
	const char *filename = luaL_checkstring(L, 1);
	LGImage *image = NULL;
	
	if ( filename ) {
		if ( (image = LoadLGImage(filename)) ) {
			lua_pushboolean(L, 1);
			lua_pushlightuserdata(L, image);
			return 2;
		}	
	}
	
	lua_pushboolean(L, 0);
	lua_pushlightuserdata(L, NULL);		
	return 2;
}


static int LuaGame_GetImageWidth(lua_State *L)
{
	LGImage *image = lua_touserdata(L, 1);
	image ? lua_pushnumber(L, image->width) : lua_pushnil(L);
	return 1;
}


static int LuaGame_GetImageHeight(lua_State *L)
{
	LGImage *image = lua_touserdata(L, 1);
	image ? lua_pushnumber(L, image->height) : lua_pushnil(L);
	return 1;
}

static int LuaGame_RenderImage(lua_State *L)
{
	LGImage *image = (LGImage *)lua_touserdata(L, 1);
	GLint x = (GLint)luaL_checknumber(L, 2);
	GLint y = (GLint)luaL_checknumber(L, 3);	

	if ( image ) {
		glEnable(GL_TEXTURE_2D);		
		if ( image->has_alpha_channel ) {
			glEnable(GL_BLEND);
			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
			glDisable(GL_DEPTH_TEST);	
		} else {
			glDisable(GL_BLEND);
			glEnable(GL_DEPTH_TEST);
		}
		
		glBindTexture(GL_TEXTURE_2D, image->texture);		
		glBegin(GL_QUADS);			
			glTexCoord2f(0.0f, 0.0f); glVertex3d(x, y-image->height, 0);
			glTexCoord2f(1.0f, 0.0f); glVertex3d(x+image->width, y-image->height, 0);
			glTexCoord2f(1.0f, 1.0f); glVertex3d(x+image->width, y, 0);
			glTexCoord2f(0.0f, 1.0f); glVertex3d(x, y, 0);	
		glEnd();
		
		if ( image->has_alpha_channel ) {
			glDisable(GL_BLEND);
			glEnable(GL_DEPTH_TEST);	
		}
		glDisable(GL_TEXTURE_2D);
	}	

	return 0;
}

static int LuaGame_Release(lua_State *L)
{
	return 0;
}

static int LuaGame_Start(lua_State *L)
{
	glutMainLoop();

#if defined(FREEIMAGE_LIB)
	FreeImage_DeInitialise();
#endif
	return 0;
}



/*
	$@@ 动态库导出函数(格式: luaopen_+库名)
*/
#define LUAGAME_REGFUNC(l, f)		lua_register(l, #f, f)
int luaopen_LuaGame(lua_State *L)
{
	G_Main.L = L;
	LUAGAME_REGFUNC(L, LuaGame_Init);
	LUAGAME_REGFUNC(L, LuaGame_CreateWindow);
	LUAGAME_REGFUNC(L, LuaGame_SetMouseMove);
	LUAGAME_REGFUNC(L, LuaGame_SetMouseDown);
	LUAGAME_REGFUNC(L, LuaGame_SetMouseDownMove);
	LUAGAME_REGFUNC(L, LuaGame_SetMouseUp);
	LUAGAME_REGFUNC(L, LuaGame_SetMouseEntry);
	LUAGAME_REGFUNC(L, LuaGame_SetMouseLeave);
	LUAGAME_REGFUNC(L, LuaGame_SetKeyboard);
	LUAGAME_REGFUNC(L, LuaGame_CreateImage);
	LUAGAME_REGFUNC(L, LuaGame_GetImageWidth);
	LUAGAME_REGFUNC(L, LuaGame_GetImageHeight);
	LUAGAME_REGFUNC(L, LuaGame_RenderImage);
	LUAGAME_REGFUNC(L, LuaGame_Start);
	LUAGAME_REGFUNC(L, LuaGame_Release);
	
	return 0;
}



YellowBug
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
alice:一个简单的 GUI 小部件库，使用 OpenGL 和 Lua
07-10
爱丽丝 Alice 是一个简单的 GUI 小部件库，由 OpenGL (ES) 提供支持并由 Lua 控制。 它目前在 OS X 和 Raspberry Pi 上构建和运行，虽然因为它使用 SDL，它应该很容易移植到标准 Linux 环境和 Windows。 建造 操作系统 您将需要以下框架： SDL2 2.0 SDL2_image 2.0 Lua 5.2 将这些安装到/Library/Frameworks ，您将能够构建 Xcode 项目，或使用 scons。 这应该适用于 10.6+，但也适用于早期版本。 树莓派 Alice 在 Raspbian 发行版上构建和运行，但应该可以在其他发行版上运行，只要您在/opt/vc有 VideoCore 库。 使用您喜欢的软件包管理界面安装以下软件包： 烤饼 liblua5.2-dev 您需要从源构建和安装 SDL2。 Raspberr
OpenGL
12-24
课程涵盖了OpenGL开发的方方面面,对开发中经常用到的开发知识点进行讲解,从实战的角度进行编码设计.第1章-环境建立第2章-基础图元第3章-三维世界第4章-纹理多彩世界第5章-显存的分配-优化第6章-场景控制第7章-光照-真实世界第8章-模型第9章-UI制作第10章-场景编辑器制作第11章-地形第12章-脚本引入-lua
探索 GENie：一款强大的Lua游戏引擎与脚本工具
最新发布
gitblog_00026的博客
04-11 403
探索 GENie：一款强大的Lua游戏引擎与脚本工具 项目地址:https://gitcode.com/bkaradzic/GENie GENie 是一个由 Bartosz Karadzić 开发的开源项目，它是一个基于 Lua 的游戏引擎和脚本工具，旨在简化游戏开发过程，提供灵活的配置和高效的代码管理。如果你是寻求高效、易用且具有高度可定制性的游戏开发解决方案，那么 GENie 绝对值得你一试。...
C++中搭建Lua脚本系统开发框架,并实现OpenGL调用
03-20
1.如何编译lua2.C++ 中调用lua函数3.lua中如何调用C++函数4.深入的介绍lua栈(lua的灵魂)5.lua闭包和上值的使用6.lua元表的使用(lua的精髓)7.实现导出C++类给lua8.实现自动化导出类给lua9.导出OpenGL函数库给lua10.游戏循环中调用lua,实现OpenGL绘制.
在Lua脚本中使用OpenGL函数
wanglang3081的专栏
01-13 1788
主要因为单纯的学习Lua太枯燥了，所以先学些了Lua基本语法然后就直接学习了与C语言的相互调用，所以以后的OpenGL代码都用Lua写，这样更容易理解Lua以及提高学习兴趣。下面是这2天的代码包括C语言部分和Lua部分，因为公司环境是Ubuntu的所以我用glut库使代码在Linux和windows下都可以使用。 C语言代码如下： [cpp] view plaincopy
三维游戏引擎的一个实例程序
09-03
本实例程序“三维游戏引擎”是一个完整的、可运行的项目，旨在帮助开发者理解游戏引擎的工作原理和实现方式。下面我们将深入探讨其中涉及的一些关键知识点。 1. **引擎架构**： 一个完整的三维游戏引擎通常由多个...
android游戏引擎基于
03-01
《Android游戏引擎：基于Cocos2D的深度解析》 在移动游戏开发领域，Android游戏引擎扮演着至关重要的角色，它们为开发者提供了高效、便捷的工具来构建丰富的游戏体验。其中，Cocos2D是一款备受青睐的游戏开发框架，...
手把手教你架构游戏引擎.rar
07-03
游戏引擎是开发电子游戏的核心工具，它集合了各种软件组件，包括图形渲染、物理模拟、音频处理、资源管理等，为开发者提供了一个高效且便捷的创作环境。本压缩包“手把手教你架构游戏引擎.rar”提供了关于构建游戏...
lgf：Lua的游戏开发框架
02-03
本文将深入探讨“lgf”（Lua Game Framework），这是一个基于Lua语言的游戏开发框架，旨在为开发者提供高效、灵活的游戏开发环境。通过结合OpenGL图形库、LuaJIT的高性能特性以及FFI（Foreign Function Interface）...
一个高性能的3D游戏引擎源代码
10-01
通常，一个3D游戏引擎由以下几个主要部分组成： 1. **图形渲染引擎**：这是3D游戏引擎的核心部分，负责将游戏场景中的3D模型、纹理、光照等信息转化为2D图像显示在屏幕上。OpenGL和DirectX是常见的图形库，用于与...
Fariy2D:由OpenGL和Lua支持的简单2D游戏引擎
04-27
Fariy2D Simple 2D Game Engine powered by OpenGL and Lua 0 参考了ejoy2d，cocos2dx，love2d等，文字绘制功能照搬的ejoyed，场景管理基本照搬的cocos2dx 1 用到的第三方库包括lua，tcmalloc，stb_image，glew等 2 程序最大的优点是简单明了，最大的缺点是绘制图形时没有合并batch，绘一张图提交一次。(不过可以修改lua来合并batch) 3 代码比较规范除了某个头文件使用了using namespace std; 4 Bin下的文件使用前请杀毒。Fairy2d.exe启动时自动加载main.lua的代码，修改main-tower.lua以及main-bomb.lua为main.lua再运行Fairy2d.exe来启动不同的demo，demo仅起功能演示作用，不完善。Dbgview.e
使用C语言和OpenGL加Lua脚本编写的一个连连看的例子
08-01
学习了一段时间的lua,所以想发挥以下lua的功能，不过只使用了lua一些简单的功能，使用纯C语言加上OpenGL和FreeImage编写的一个简单的连连看的例子，框架已经打好了，还需要添加连连看的核心算法，这里只是提供一个lua作为游戏脚本的例子，我也是初次练习，只是供参考而已。
使用C语言和OpenGL写的简单的Lua游戏引擎(带lua例子)
07-08
使用C语言和OpenGL编写的一个简单的Lua游戏引擎， 主要是为了学习lua，带了一个简单的lua的例子，lua的逻辑还没有完成,测试环境是ubuntu 10.04 + GCC
Lua2D游戏脚本引擎(渲染OpenGL)
03-29
MLWD_2d游戏引擎.完全与Lua绑定..可以在Lua里控制引擎渲染.附带一个小游戏Demo.典型的Sprite引擎.本人开发.可以随意使用.........不用上来问我哪找的了.就是我写的...
C语言和Lua编写的连连看源码(OpenGL)
08-02
这个较之前的版本加入了连连看算法(一个简单的寻路算法), 加入了选中提示和右键清除选中（R键重置地图）， 主要语言C，脚本语言Lua，渲染引擎OpenGL，图像解析FreeImage， 连连看基本功能，这里主要不是注重游戏本身而是作为一个C语言和Lua编写游戏的参考，因为是第一次写，所以请大家有什么建议可以发给我。如果大家还有好的寻路算法也可以自己在lua脚本里编写。（开发环境：windows XP+VS2008， Lua和FreeImage库已经在源码中，OpenGL需要自己下载,我用的是VS2008自带的OpenGL库）
服务器鼠标消息无效,关于mouse_event和sendinput无效的原因
weixin_35610373的博客
08-10 895
FFmpeg-for IOS 一&lbrack;安装&rsqb;FFmpeg编译环境搭建 准备 下载 gas-preprocessor 下载 ffmpeg包,ffmpeg 安装yasm,先安装homebrew,输入:ruby -e "$(curl -fs ...Unity Application 前后台切换调用关系[Unity Application 前后台切换调用关系] http...
QQ游戏外挂mouse_event不起作用的原因,及我的对对碰外挂程序.
阿东的程序空间
05-17 3897
/////////////////////////////////////////////////////////////////////// 作者 : 阿东// 主页 : http://adong2008.512j.com// 邮箱 : dongfa@yeah.net// MSN  : codelive@hotmail.com// 日期 : 2005.02.06/////////////////
Doris一款为Lua制作的小巧OpenGL封装
suxiaojack的专栏
05-28 3309
 Doris is a Lua script driven OpenGL viewer with GUI widget extensions. Lua is a fast, powerful, portable scripting language. Lua bindings are provided to OpenGL, GLUT, GLUI (a GL widget library) and
用lua写一个游戏脚本
05-19
好的，下面是一个简单的示例游戏脚本，它将创建一个窗口并显示一张图片。你可以根据自己的需要进行修改： ```lua -- 导入必要的模块 local love = require("love") local graphics = love.graphics -- 窗口的宽度...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值