OpenGL: 水果忍者刀锋效果

最新推荐文章于 2022-02-21 16:14:24 发布
最新推荐文章于 2022-02-21 16:14:24 发布
阅读量2.6k 收藏 3
点赞数
分类专栏： OpenGL

http://www.cnblogs.com/lghost/archive/2012/05/05/2484888.html

 

修复版1

修复版2

之前在视频中许诺过五一之后写个关于这个刀锋实现的文章的，但发现最近真的很忙。。。。所以。。。先放出到现在为止的源代码，具体实现思路和方法以后再补上。

Ninja.cpp

#include <Windows.h>
#include <GL/glut.h>
#include "Blade.h"

#ifndef _LINUX_
#include <windows.h>
void mySleep(int millisecond) {Sleep(millisecond);};
#else
#include <unistd.h>
void mySleep(int millisecond) {sleep((float)millisecond/1000.0);};
#endif

Blade myBlade;

const int sleepTime = 1;

void display(void )
{
	glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT);

	myBlade.drawBlade();

	glutSwapBuffers();
}

void mouseButton(int btn, int state, int x, int y)
{
	myBlade.mouse2BladeState(btn, state, x, y);
	//if (btn == GLUT_RIGHT_BUTTON)
	//    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}

void reshape(int w, int h)
{
	myBlade.winWidth = w;
	myBlade.winHeight = h;
}

void mouseMove(int x, int y)
{
	myBlade.mousePosX = x;
	myBlade.mousePosY = y;
}

void idle(void)
{
	mySleep(sleepTime);

	myBlade.sampleFadeBlade();
}
int main(int argc, char *argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(800, 600);
	glutCreateWindow("Ninjia blade");

	gluOrtho2D(0.0f, 1.0f, 0.0f, 1.0f);
	myBlade.recordOrthoData(0.0f, 1.0f, 0.0f, 1.0f);
	//gluOrtho2D(0.0f, -1.0f, -2.0f, 1.0f);
	//myBlade.recordOrthoData(0.0f, -1.0f, -2.0f, 1.0f);
	glEnable(GL_LINE_SMOOTH);

	glEnable(GL_CULL_FACE);
	glFrontFace(GL_CCW);

	glutDisplayFunc(&display);
	glutMouseFunc(&mouseButton);
	glutReshapeFunc(&reshape);
	glutMotionFunc(&mouseMove);
	glutIdleFunc(&idle);

	glutMainLoop();
	return 0;
}

Blade.h

#ifndef _BLADE_H_
#define _BLADE_H_

#include <GL/glut.h>
#include <time.h>

class Blade
{
public :
	int winWidth, winHeight;
	GLint mousePosX, mousePosY;

	Blade();
	~Blade();

	void drawBlade(void );
	void sampleFadeBlade(void);
	void mouse2BladeState(int btn, int state, int x, int y);

	void recordOrthoData(GLfloat left, GLfloat right, GLfloat bottom, GLfloat up);

private :
	static const int MAXTIMER = 10;
	static const int vertexArrHead = 0;
	static const int vertexArrTail = 20;
	static const int POINTTHRESHOLD = 16;
	static const GLint sampleTimerFlag = 0;
	static const GLint fadeTimerFlag = 1;

	int vertexArrStartPos;
	//int vertexArrEndPos;

	GLint pointCount;
	GLint drawFlag;
	GLint mouseDownFlag;    
	GLfloat bodyVertex[vertexArrTail][2];
	GLfloat uniformSideVertex[vertexArrTail][2][2];
	GLfloat outerSideVertex[vertexArrTail][2][2];
	GLfloat innerSideVertex[vertexArrTail][2][2];
	GLfloat bladeThreshold;

	clock_t start[MAXTIMER], finish[MAXTIMER];
	GLfloat sampleInterval;
	GLfloat fadeInterval;

	GLfloat orthoLeft;
	GLfloat orthoRight;
	GLfloat orthoBottom;
	GLfloat orthoUp;

	void init(void);
	void calcSideVertex(GLfloat *startVertex, GLfloat *endVertex, GLfloat returnSideVertex[][2], GLfloat sideWidth, GLfloat end2StartRatio);
	void vertexSampling();
	GLint isTimeUp(GLint timerFlag, GLfloat timeInterval);
	void vertexFading(void );
	void recalculateBladeWidth(void );
};

#endif

Blade.cpp

#include "Blade.h"
#include <GL/glut.h>
#include <math.h>
//#include <stdio.h>
#include <time.h> 
//#include <stdlib.h>

Blade::Blade()
{
	winWidth = 0;
	winHeight = 0;
	mousePosX = 0;
	mousePosY = 0;

	vertexArrStartPos = 0;
	//vertexArrEndPos = 0;

	pointCount = 0;
	drawFlag = 0;
	mouseDownFlag = 0;    

	sampleInterval = 0.015f;
	fadeInterval = 0.02f;

	bladeThreshold = 0.032f;

	init();
}

Blade::~Blade()
{}

void Blade::calcSideVertex(GLfloat *startVertex, GLfloat *endVertex, GLfloat returnSideVertex[][2], GLfloat sideWidth, GLfloat end2StartRatio)
{
	GLfloat tmpAngle = 0.0;
	GLfloat tmpVertex[2] = {0.0f, 0.0f};
	GLfloat tmpSideVertex[2][2] = {{0.0f, 0.0f}, {0.0f, 0.0f}};
	GLfloat tmpResult = 0.0;

	tmpAngle = atan((endVertex[1] - startVertex[1])/(endVertex[0] - startVertex[0]));

	tmpVertex[0] = endVertex[0]-(endVertex[0]-startVertex[0])*end2StartRatio;
	tmpVertex[1] = endVertex[1]-(endVertex[1]-startVertex[1])*end2StartRatio;

	if (endVertex[0] > startVertex[0]) {
		tmpSideVertex[0][0] = tmpVertex[0] + (sideWidth * sin(tmpAngle));
		tmpSideVertex[0][1] = tmpVertex[1] - (sideWidth * cos(tmpAngle));
		tmpSideVertex[1][0] = tmpVertex[0] - (sideWidth * sin(tmpAngle));
		tmpSideVertex[1][1] = tmpVertex[1] + (sideWidth * cos(tmpAngle));
	} else {
		tmpSideVertex[0][0] = tmpVertex[0] - (sideWidth * sin(tmpAngle));
		tmpSideVertex[0][1] = tmpVertex[1] + (sideWidth * cos(tmpAngle));
		tmpSideVertex[1][0] = tmpVertex[0] + (sideWidth * sin(tmpAngle));
		tmpSideVertex[1][1] = tmpVertex[1] - (sideWidth * cos(tmpAngle));
	}

	//判断点在向量的左边还是右边
	tmpResult = (startVertex[0] - tmpSideVertex[0][0])*(endVertex[1] - tmpSideVertex[0][1]) - (startVertex[1] - tmpSideVertex[0][1])*(endVertex[0] - tmpSideVertex[0][0]);
	if (tmpResult > 0.0f) {
		returnSideVertex[0][0] = tmpSideVertex[1][0];
		returnSideVertex[0][1] = tmpSideVertex[1][1];
		returnSideVertex[1][0] = tmpSideVertex[0][0];
		returnSideVertex[1][1] = tmpSideVertex[0][1];
	} else {
		returnSideVertex[0][0] = tmpSideVertex[0][0];
		returnSideVertex[0][1] = tmpSideVertex[0][1];
		returnSideVertex[1][0] = tmpSideVertex[1][0];
		returnSideVertex[1][1] = tmpSideVertex[1][1];
	}
}

void Blade::init(void)
{
	int i = 0;

	for (i = 0; i < vertexArrTail; i++)    {
		bodyVertex[i][0] = 0.0f;
		bodyVertex[i][1] = 0.0f;

		uniformSideVertex[i][0][0] = 0.0f;
		uniformSideVertex[i][0][1] = 0.0f;
		uniformSideVertex[i][1][0] = 0.0f;
		uniformSideVertex[i][1][1] = 0.0f;

		outerSideVertex[i][0][0] = 0.0f;
		outerSideVertex[i][0][1] = 0.0f;
		outerSideVertex[i][1][0] = 0.0f;
		outerSideVertex[i][1][1] = 0.0f;

		innerSideVertex[i][0][0] = 0.0f;
		innerSideVertex[i][0][1] = 0.0f;
		innerSideVertex[i][1][0] = 0.0f;
		innerSideVertex[i][1][1] = 0.0f;        
	}
}

void Blade::vertexSampling()
{
	int tmpIndex1 = 0, tmpIndex2 = 0;
	GLfloat uniformX = 0.0f, uniformY = 0.0f;
	GLfloat realX = 0.0f, realY = 0.0f;
	drawFlag = 0;
	pointCount++;

	uniformX = (GLfloat)mousePosX / (GLfloat)winWidth;
	uniformY = (GLfloat)(winHeight - mousePosY) / (GLfloat)winHeight;
	realX = uniformX*(orthoRight - orthoLeft) + orthoLeft;
	realY = uniformY*(orthoUp - orthoBottom) + orthoBottom;
	if (pointCount == 0) {
		bodyVertex[vertexArrStartPos][0] = realX;
		bodyVertex[vertexArrStartPos][1] = realY;
	} else {
		tmpIndex1 = (vertexArrStartPos + pointCount - 1)%vertexArrTail;
		tmpIndex2 = (tmpIndex1 + 1)%vertexArrTail;

		bodyVertex[tmpIndex2][0] = realX;
		bodyVertex[tmpIndex2][1] = realY;

		calcSideVertex(bodyVertex[tmpIndex1], bodyVertex[tmpIndex2], uniformSideVertex[tmpIndex2], bladeThreshold, 0.4);
	}    
	if (pointCount >= 3)
		drawFlag = 1;
	//vertexArrEndPos++;
	//if (vertexArrEndPos >= vertexArrTail)
	//    vertexArrEndPos -= vertexArrTail;
}

GLint Blade::isTimeUp(GLint timerFlag, GLfloat timeInterval)
{
	double duration = 0.0;

	finish[timerFlag] = clock();
	duration = (double)(finish[timerFlag] - start[timerFlag]) / CLOCKS_PER_SEC;
	if (duration >= timeInterval) {
		start[timerFlag] = clock();
		return 1;
	}
	return 0;
}

void Blade::vertexFading()
{
	vertexArrStartPos++;
	if (vertexArrStartPos >= vertexArrTail)
		vertexArrStartPos -= vertexArrTail;
	pointCount--;
	if (pointCount <= 2)
		drawFlag = 0;
}

void Blade::recalculateBladeWidth(void )
{
	int i = 0;    
	int tmpIndex = 0;
	GLfloat ratio = 0.0f;
	GLfloat tmp[4] = {0.0f, 0.0f, 0.0f, 0.0f};

	//reclaculate the blade width
	for (i = 1; i < pointCount - 1; i++) {
		tmpIndex = (vertexArrStartPos + i)%vertexArrTail;
		tmp[0] = uniformSideVertex[tmpIndex][0][0] + uniformSideVertex[tmpIndex][1][0];
		tmp[1] = uniformSideVertex[tmpIndex][0][0] - uniformSideVertex[tmpIndex][1][0];
		tmp[2] = uniformSideVertex[tmpIndex][0][1] + uniformSideVertex[tmpIndex][1][1];
		tmp[3] = uniformSideVertex[tmpIndex][0][1] - uniformSideVertex[tmpIndex][1][1];
		if (i == (pointCount-2))
			ratio = 1.0;
		else
			ratio = (GLfloat)i/(GLfloat)pointCount;

		outerSideVertex[tmpIndex][0][0] = 0.5*(tmp[0] + ratio*tmp[1]);
		outerSideVertex[tmpIndex][0][1] = 0.5*(tmp[2] + ratio*tmp[3]);
		outerSideVertex[tmpIndex][1][0] = 0.5*(tmp[0] - ratio*tmp[1]);
		outerSideVertex[tmpIndex][1][1] = 0.5*(tmp[2] - ratio*tmp[3]);

		innerSideVertex[tmpIndex][0][0] = 0.5*(tmp[0] + ratio*2.0/3.0*tmp[1]);
		innerSideVertex[tmpIndex][0][1] = 0.5*(tmp[2] + ratio*2.0/3.0*tmp[3]);
		innerSideVertex[tmpIndex][1][0] = 0.5*(tmp[0] - ratio*2.0/3.0*tmp[1]);
		innerSideVertex[tmpIndex][1][1] = 0.5*(tmp[2] - ratio*2.0/3.0*tmp[3]);
	}
}



void Blade::drawBlade()
{
	int i = 0;

	//printf("%d\n", pointCount);
	//printf("%d\n", vertexArrStartPos);
	//printf("Flag:%d\n\n", drawFlag);

	if (drawFlag == 0){
		return;
	}

	/*****--------------------------------------*****/
	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	//glPolygonMode(GL_FRONT, GL_LINE);
	/*****--------------------------------------*****/
	//draw the outer blade
	glColor4f(0.2f, 0.2f, 0.9f, 0.5f);
	glBegin(GL_POLYGON);
	glVertex2fv(bodyVertex[vertexArrStartPos]);
	glVertex2fv(outerSideVertex[(vertexArrStartPos+1)%vertexArrTail][0]);
	glVertex2fv(outerSideVertex[(vertexArrStartPos+1)%vertexArrTail][1]);
	glEnd();
	for (i = 1; i < pointCount - 2; i++)    {
		glBegin(GL_POLYGON);
		glVertex2fv(outerSideVertex[(vertexArrStartPos + i)%vertexArrTail][0]);
		glVertex2fv(outerSideVertex[(vertexArrStartPos + i + 1)%vertexArrTail][0]);
		glVertex2fv(outerSideVertex[(vertexArrStartPos + i)%vertexArrTail][1]);
		glEnd();
		glBegin(GL_POLYGON);
		glVertex2fv(outerSideVertex[(vertexArrStartPos + i + 1)%vertexArrTail][1]);
		glVertex2fv(outerSideVertex[(vertexArrStartPos + i)%vertexArrTail][1]);
		glVertex2fv(outerSideVertex[(vertexArrStartPos + i + 1)%vertexArrTail][0]);
		glEnd();
	}
	glBegin(GL_POLYGON);
	glVertex2fv(outerSideVertex[(vertexArrStartPos + pointCount - 2)%vertexArrTail][0]);        
	glVertex2fv(bodyVertex[(vertexArrStartPos + pointCount - 1)%vertexArrTail]);
	glVertex2fv(outerSideVertex[(vertexArrStartPos + pointCount - 2)%vertexArrTail][1]);
	glEnd();


	//draw the inner blade
	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	glBegin(GL_POLYGON);
	glVertex2fv(bodyVertex[vertexArrStartPos]);
	glVertex2fv(innerSideVertex[(vertexArrStartPos+1)%vertexArrTail][0]);
	glVertex2fv(innerSideVertex[(vertexArrStartPos+1)%vertexArrTail][1]);
	glEnd();

	for (i = 1; i < pointCount - 2; i++)    {
		glBegin(GL_POLYGON);
		glVertex2fv(innerSideVertex[(vertexArrStartPos + i)%vertexArrTail][0]);
		glVertex2fv(innerSideVertex[(vertexArrStartPos + i + 1)%vertexArrTail][0]);
		glVertex2fv(innerSideVertex[(vertexArrStartPos + i)%vertexArrTail][1]);
		glEnd();
		glBegin(GL_POLYGON);
		glVertex2fv(innerSideVertex[(vertexArrStartPos + i + 1)%vertexArrTail][1]);
		glVertex2fv(innerSideVertex[(vertexArrStartPos + i)%vertexArrTail][1]);
		glVertex2fv(innerSideVertex[(vertexArrStartPos + i + 1)%vertexArrTail][0]);
		glEnd();
	}
	glBegin(GL_POLYGON);
	glVertex2fv(innerSideVertex[(vertexArrStartPos + pointCount - 2)%vertexArrTail][0]);        
	glVertex2fv(bodyVertex[(vertexArrStartPos + pointCount - 1)%vertexArrTail]);
	glVertex2fv(innerSideVertex[(vertexArrStartPos + pointCount - 2)%vertexArrTail][1]);
	glEnd();
}

void Blade::sampleFadeBlade(void)
{
	if (mouseDownFlag == 1) {
		sampleInterval = (pointCount <= 2 ? 0.005 : 0.015);

		if (isTimeUp(sampleTimerFlag, sampleInterval) == 1) {
			vertexSampling();
			recalculateBladeWidth();
			glutPostRedisplay();
		}
	}

	if (pointCount > 0) {
		fadeInterval = (pointCount >= POINTTHRESHOLD ? 0.0 : 0.016);
		fadeInterval = (mouseDownFlag == 0 ? 0.0 : fadeInterval);
		//printf("%f\n", fadeInterval);

		if (isTimeUp(fadeTimerFlag, fadeInterval) == 1) {
			vertexFading();
			recalculateBladeWidth();
			glutPostRedisplay();
		}
	}
}

void Blade::mouse2BladeState(int btn, int state, int x, int y)
{
	if (btn == GLUT_LEFT_BUTTON) {
		if (state == GLUT_DOWN) {            
			mousePosX = x;
			mousePosY = y;
			mouseDownFlag = 1;

			start[sampleTimerFlag] = clock();
			start[fadeTimerFlag] = clock();

			pointCount = 0;
		} else if (state == GLUT_UP) {
			mouseDownFlag = 0;
		}
	}
}

void Blade::recordOrthoData(GLfloat left, GLfloat right, GLfloat bottom, GLfloat up)
{
	orthoLeft = left;
	orthoRight = right;
	orthoBottom = bottom;
	orthoUp = up;
}


 

只要将以上三个文件放到同一个工程编译即可。

程序入口(main函数)在Ninjia.cpp文件中定义。

 

对了！要感谢这篇文章的作者，他给了我思路。其实，我的工作也大概是将他的翻译成OpenGL版本并且再做点修改而已。

http://www.blogjava.net/oathleo/archive/2011/09/23/android_Fruit_Ninja.html


 

Augusdi
关注
专栏目录
【OpenGL】水果忍者的刀锋模拟程序
lafay626的博客
01-04 452
学习OpenGL的一个好玩程序,没想到它的功能那么厉害,有三个文件,虽然不是本人原创,是大神分享的,在这里给大家分享一下 #ifndef _BLADE_H_ #define _BLADE_H_ #include #include class Blade { public : int winWidth, winHeight;
cocos2d 水果忍者刀锋(openGL)
09-20
自己看吧 基本跟水果忍者相同！
水果忍者完整源码-刀光特效全有
05-14
水果忍者完整版源码，包含所有特效刀光，c++开发，适合android与ios。
Cocos2d-x 水果忍者划痕效果
xidajiancun
12-27 244
网上找的一个关于水果忍者划痕的，效果还算凑合。其原理就是基于OpenGL绘制直线，由于版本过老，此处笔者修改了一些方法，粘贴后可直接使用 适用于Cocos2d-x 2.2.1 .h文件中需要加入的代码： void draw(); void drawLine(); virtual void ccTouchesBegan(CCSet *pTouches,CCEvent *pEvent...
Android上的水果忍者刀锋效果（JAVA实现）
weixin_30882895的博客
08-21 256
显示刀锋的View package com.wbhuang.myninjia; import java.util.ArrayList; import java.util.List; import android.content.Context; import android.graphics.Canvas; import android.graphics.Color; i...
android 仿水果忍者 刀锋效果源码
12-20
本项目“android 仿水果忍者 刀锋效果源码”旨在提供一种实现游戏中刀锋切割效果的方法。接下来，我们将深入探讨这个项目的重点内容。 首先，我们要了解的是Android的图形渲染技术。在“水果忍者”中，刀锋划过屏幕...
水果忍者刀光效果
04-03
《水果忍者刀光效果——探索iOS游戏开发的光影魅力》 在移动游戏领域，《水果忍者》无疑是一款经典之作，其独特的切水果玩法和华丽的视觉效果深受玩家喜爱。尤其是刀光效果，它不仅提升了游戏的趣味性，还极大地...
Android应用源码之水果忍者点击屏幕效果-IT计算机-毕业设计.zip
04-06
本篇文章将详细解析“Android应用源码之水果忍者点击屏幕效果”的实现过程，帮助读者掌握Android游戏开发中的关键技巧。 一、项目概述 “水果忍者”是一款广受欢迎的休闲游戏，其核心玩法就是通过手指滑动屏幕切割...
水果忍者游戏
04-05
OpenGL是一种跨语言、跨平台的编程接口，用于渲染2D、3D矢量图形，使得游戏中的水果、刀具等元素的动画效果流畅且逼真。 4. **碰撞检测**：在水果忍者中，准确的碰撞检测是至关重要的，它决定了玩家的刀是否成功切...
cocos2d-x C++实现切水果刀刃效果
01-18
本人从不传没有验证的东西，下载的如有不懂欢迎咨询
cocos2d-X水果忍者效果demo
11-15
一个类似于水果忍者游戏的效果，分享代码，希望有帮助！
openGL特效动画集合
07-02
openGL特效动画包，包含7个动画的工程文件，其中包含水波流动，粒子特效，魔幻特效等效果的动画
水果忍者-：这是用C ++和OpenGL制作的水果忍者游戏
02-14
水果忍者- 这是用C ++和OpenGL制作的水果忍者游戏。 该游戏最初是在具有OpenGL支持的CodeBlocks中开发的。 用CodeBlocks打开项目文件，游戏应该运行而无需其他代码。 完整注释包含在文件中。 祝您学习愉快！ 胡阳明
水果忍者点击屏幕效果
06-03
简单地实现水果忍者屏幕点击效果，有兴趣的拿去玩玩，大牛就不需要了，初学者可以拿来参考参考。
【CodeVS】p1299 切水果
weixin_30236595的博客
01-04 160
题目描述Description 简单的说,一共N个水果排成一排,切M次,每次切[L,R]区间的所有水果(可能有的水果被重复切),每切完一次输出剩下水果数量 数据已重新装配，不会出现OLE错误 时限和数据范围适当修改，避免数据包过大而浪费空间资源 输入描述Input Description 第1行共包括2个正整数，分别为N,M。 接下来m行每行两个正...
做android版水果忍者有感
linger(心怀梦想，活在当下，知乎ID：linger liu)
06-25 3039
做android版水果忍者有感        大三下学期选了门专选叫动漫和网络游戏原理，课程设计我们小组选了做android版的水果忍者。有些小组是用之前做过的游戏改进一下来提交，但我不想这样，一来是对之前的作品不满意，二来是想学一下android，于是选了这个作业。这也是我第一次接触手机开发。        刚开始其实是很迷茫的，不知道怎么做。其实关键是自己没有查资料，也没有请教同学。这次作
Babylon.js开发代码片段 1
weixin_42814475的博客
02-21 2125
Babylon.js学习
使用BabylonJS 的简略笔记
小蟀闯江湖
05-30 3449
Light:var light = new BABYLON.HemisphericLight("light1", new BABYLON.Vector3(0, 1, 0), scene);//环境光var light1 = new BABYLON.DirectionalLight('light1', new BABYLON.Vector3(0, 3, 0), scene);//太阳光 直射光lig...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值