Golden_Shadow

Math.cpp

#include "Math.h"
#include "Camera.h"

Cube ::Cube(float x, float y, float z)
{
	vertexCount = 8 ;
	polyCount = 12 ;

	position.x = x ;
	position.y = y ;
	position.z = z ;

	float scaler = 0.2 ;

	localVertices[0].x = -50  * scaler ;
	localVertices[0].y = 50 * scaler ;
	localVertices[0].z = -50 * scaler ;
	localVertices[0].w = 1 ;

	localVertices[1].x = 50 * scaler ;
	localVertices[1].y = 50 * scaler ;
	localVertices[1].z = -50 * scaler ;
	localVertices[1].w = 1 ;

	localVertices[2].x = 50 * scaler ;
	localVertices[2].y = -50 * scaler ;
	localVertices[2].z = -50 * scaler ;
	localVertices[2].w = 1 ;

	localVertices[3].x = -50 * scaler ;
	localVertices[3].y = -50 * scaler ;
	localVertices[3].z = -50 * scaler ;
	localVertices[3].w = 1 ;

	localVertices[4].x = 50 * scaler ;
	localVertices[4].y = 50 * scaler ;
	localVertices[4].z = 50 * scaler ;
	localVertices[4].w = 1 ;

	localVertices[5].x = 50 * scaler ;
	localVertices[5].y = -50 * scaler ;
	localVertices[5].z = 50 * scaler ;
	localVertices[5].w = 1 ;

	localVertices[6].x = -50 * scaler ;
	localVertices[6].y = -50 * scaler ;
	localVertices[6].z = 50 * scaler ;
	localVertices[6].w = 1 ;

	localVertices[7].x = -50 * scaler ;
	localVertices[7].y = 50 * scaler ;
	localVertices[7].z = 50 * scaler ;
	localVertices[7].w = 1 ;

	polygones[0].pVertexList = transformedVertices ;
	polygones[0].vertexIndexArray[0] = 0 ;
	polygones[0].vertexIndexArray[1] = 3 ;
	polygones[0].vertexIndexArray[2] = 2 ;

	polygones[1].pVertexList = transformedVertices ;
	polygones[1].vertexIndexArray[0] = 0 ;
	polygones[1].vertexIndexArray[1] = 2 ;
	polygones[1].vertexIndexArray[2] = 1 ;

	polygones[2].pVertexList = transformedVertices ;
	polygones[2].vertexIndexArray[0] = 1 ;
	polygones[2].vertexIndexArray[1] = 2 ;
	polygones[2].vertexIndexArray[2] = 5 ;

	polygones[3].pVertexList = transformedVertices ;
	polygones[3].vertexIndexArray[0] = 1 ;
	polygones[3].vertexIndexArray[1] = 5 ;
	polygones[3].vertexIndexArray[2] = 4 ;

	polygones[4].pVertexList = transformedVertices ;
	polygones[4].vertexIndexArray[0] = 4 ;
	polygones[4].vertexIndexArray[1] = 5 ;
	polygones[4].vertexIndexArray[2] = 6 ;

	polygones[5].pVertexList = transformedVertices ;
	polygones[5].vertexIndexArray[0] = 4 ;
	polygones[5].vertexIndexArray[1] = 6;
	polygones[5].vertexIndexArray[2] = 7 ;

	polygones[6].pVertexList = transformedVertices ;
	polygones[6].vertexIndexArray[0] = 7 ;
	polygones[6].vertexIndexArray[1] = 6 ;
	polygones[6].vertexIndexArray[2] = 3 ;

	polygones[7].pVertexList = transformedVertices ;
	polygones[7].vertexIndexArray[0] = 7 ;
	polygones[7].vertexIndexArray[1] = 3 ;
	polygones[7].vertexIndexArray[2] = 0 ;

	polygones[8].pVertexList = transformedVertices ;
	polygones[8].vertexIndexArray[0] = 7 ;
	polygones[8].vertexIndexArray[1] = 0 ;
	polygones[8].vertexIndexArray[2] = 1 ;

	polygones[9].pVertexList = transformedVertices ;
	polygones[9].vertexIndexArray[0] = 4 ;
	polygones[9].vertexIndexArray[1] = 7 ;
	polygones[9].vertexIndexArray[2] = 1 ;

	polygones[10].pVertexList = transformedVertices ;
	polygones[10].vertexIndexArray[0] = 3 ;
	polygones[10].vertexIndexArray[1] = 6 ;
	polygones[10].vertexIndexArray[2] = 5 ;

	polygones[11].pVertexList = transformedVertices ;
	polygones[11].vertexIndexArray[0] = 2 ;
	polygones[11].vertexIndexArray[1] = 3 ;
	polygones[11].vertexIndexArray[2] = 5 ;
}

void Cube ::RotateAroundX(float unit)
{
	float sinTheta = sin(DEGREE_TO_RADIAN((unit))) ;
	float cosTheta = cos(DEGREE_TO_RADIAN((unit))) ;

	Matrix4X4 rotateAroundY = {
		1, 0, 0, 0,
		0, cosTheta, sinTheta, 0,
		0, -sinTheta, cosTheta, 0,
		0, 0, 0, 1
	} ;

	Vector4 temp ;

	for (int i = 0; i < vertexCount; ++i)
	{
		VectorMultMatrix(&localVertices[i], &rotateAroundY, &temp) ;
		localVertices[i].x = temp.x ;
		localVertices[i].y = temp.y ;
		localVertices[i].z = temp.z ;
		localVertices[i].w = temp.w ;
	}
}

void Cube ::RotateAroundY(float unit)
{
	float sinTheta = sin(DEGREE_TO_RADIAN((unit))) ;
	float cosTheta = cos(DEGREE_TO_RADIAN((unit))) ;

	Matrix4X4 rotateAroundY = {
		cosTheta, 0, -sinTheta, 0,
		0, 1, 0, 0,
		sinTheta, 0, cosTheta, 0,
		0, 0, 0, 1
	} ;

	Vector4 temp ;

	for (int i = 0; i < vertexCount; ++i)
	{
		VectorMultMatrix(&localVertices[i], &rotateAroundY, &temp) ;
		localVertices[i].x = temp.x ;
		localVertices[i].y = temp.y ;
		localVertices[i].z = temp.z ;
		localVertices[i].w = temp.w ;
	}
}

void Cube ::RotateAroundZ(float unit)
{
	float sinTheta = sin(DEGREE_TO_RADIAN((unit))) ;
	float cosTheta = cos(DEGREE_TO_RADIAN((unit))) ;

	Matrix4X4 rotateAroundZ = {
		cosTheta, sinTheta, 0, 0,
		-sinTheta, cosTheta, 0, 0,
		0, 0, 1, 0,
		0, 0, 0, 1
	} ;

	Vector4 temp ;

	for (int i = 0; i < vertexCount; ++i)
	{
		VectorMultMatrix(&localVertices[i], &rotateAroundZ, &temp) ;
		localVertices[i].x = temp.x ;
		localVertices[i].y = temp.y ;
		localVertices[i].z = temp.z ;
		localVertices[i].w = temp.w ;
	}
}

void VectorPlusVector(Vector3* lhs, Vector3* rhs, Vector3* pResult)
{
	pResult ->x = lhs ->x + rhs ->x ;
	pResult ->y = lhs ->y + rhs ->y ;
	pResult ->z = lhs ->z + rhs ->z ;
}

void VectorMinusVector(Vector3* endPoint, Vector3* startPoint, Vector3* pResult)
{
	pResult ->x = endPoint ->x - startPoint ->x ;
	pResult ->y = endPoint ->y - startPoint ->y ;
	pResult ->z = endPoint ->z - startPoint ->z ;
}

void VectorCrossVector(Vector3* lhs, Vector3* rhs, Vector3* pResult)
{
	pResult ->x = lhs ->y * rhs ->z - lhs ->z * rhs ->y ;
	pResult ->y = lhs ->z * rhs ->x - lhs ->x * rhs ->z ;
	pResult ->z = lhs ->x * rhs ->y - lhs ->y * rhs ->x ;
}

float VectorDotVector(Vector3* lhs, Vector3* rhs)
{
	return lhs ->x * rhs ->x + lhs ->y * rhs ->y + lhs ->z * rhs ->z ;
}

void Vector4ToVector3(Vector4* resourcePoint, Vector3* newPoint)
{
	newPoint ->x = resourcePoint ->x / resourcePoint ->w ;
	newPoint ->y = resourcePoint ->y / resourcePoint ->w ;
	newPoint ->z = resourcePoint ->z / resourcePoint ->w ;
}

void InitializeMatrix(Matrix3X3* pMatrix,
	float m11, float m12, float m13,
	float m21, float m22, float m23,
	float m31, float m32, float m33)
{
	pMatrix ->m11 = m11 ; 	pMatrix ->m12 = m12 ; 	pMatrix ->m13 = m13 ;
	pMatrix ->m21 = m21 ; 	pMatrix ->m22 = m22 ; 	pMatrix ->m23 = m23 ;
	pMatrix ->m31 = m31 ; 	pMatrix ->m32 = m32 ; 	pMatrix ->m33 = m33 ;
}

void InitializeMatrix(Matrix4X4* pMatrix,
	float m11, float m12, float m13, float m14,
	float m21, float m22, float m23, float m24,
	float m31, float m32, float m33, float m34,
	float m41, float m42, float m43, float m44)
{
	pMatrix ->m11 = m11 ; 	pMatrix ->m12 = m12 ; 	pMatrix ->m13 = m13 ; pMatrix ->m14 = m14 ;
	pMatrix ->m21 = m21 ; 	pMatrix ->m22 = m22 ; 	pMatrix ->m23 = m23 ; pMatrix ->m24 = m24 ;
	pMatrix ->m31 = m31 ; 	pMatrix ->m32 = m32 ; 	pMatrix ->m33 = m33 ; pMatrix ->m34 = m34 ;
	pMatrix ->m41 = m41 ; 	pMatrix ->m42 = m42 ; 	pMatrix ->m43 = m43 ; pMatrix ->m44 = m44 ;
}

void VectorMultMatrix(Vector4* point, Matrix4X4* matrix, Vector4* pResult)
{
	for (int col = 0; col < 4; ++col)
	{
		float sum = 0 ;

		for (int row = 0; row < 4; ++row)
			sum += point ->M[row] * matrix ->M[row][col] ;

		pResult ->M[col] = sum ;
	}
}

void MatrixMultMatrix(Matrix4X4* lhs, Matrix4X4* rhs, Matrix4X4* pResult)
{
	for (int row = 0; row < 4; ++row)
	{
		for (int col = 0; col < 4; ++col)
		{
			float temp = 0 ;

			for (int i = 0; i < 4; ++i)
				temp += lhs ->M[row][i] * rhs ->M[i][col] ;

			pResult ->M[row][col] = temp ;
		}
	}
}

float GetDeterminant(const Matrix4X4* pMatrix)
{
	return pMatrix ->m11 * pMatrix ->m22 * pMatrix ->m33 * pMatrix ->m44 - pMatrix ->m11 * pMatrix ->m24 * pMatrix ->m33 * pMatrix ->m42
		+ pMatrix ->m12 * pMatrix ->m23 * pMatrix ->m34 * pMatrix ->m41 - pMatrix ->m12 * pMatrix ->m21 * pMatrix ->m34 * pMatrix ->m43
		+ pMatrix ->m13 * pMatrix ->m24 * pMatrix ->m31 * pMatrix ->m42 - pMatrix ->m13 * pMatrix ->m22 * pMatrix ->m31 * pMatrix ->m44
		+ pMatrix ->m14 * pMatrix ->m21 * pMatrix ->m32 * pMatrix ->m43 - pMatrix ->m14 * pMatrix ->m23 * pMatrix ->m32 * pMatrix ->m41 ;
}

void ScaleAccordingTo(Cube* pCube, Vector3* pAxis, float k)
{
	Matrix4X4 matrix = {
		1 + (k - 1) * pAxis ->x * pAxis ->x, (k - 1) * pAxis ->x * pAxis ->y, (k - 1) * pAxis ->x * pAxis ->z, 0, 
		(k - 1) * pAxis ->x * pAxis ->y, 1 + (k - 1) * pAxis ->y * pAxis ->y, (k - 1) * pAxis ->y * pAxis ->z, 0, 
		(k - 1) * pAxis ->x * pAxis ->z, (k - 1) * pAxis ->z * pAxis ->y, 1 + (k - 1) * pAxis ->z * pAxis ->z, 0,
		0, 0, 0, 1
	} ;

	for (int i = 0; i < pCube ->vertexCount; ++i)
		VectorMultMatrix(&pCube ->localVertices[i], &matrix, &pCube ->localVertices[i]) ;
}

void ModelToWorld(Cube* pCube)
{
	for (int i = 0; i < pCube ->vertexCount; ++i)
	{
		pCube ->transformedVertices[i].x = pCube ->localVertices[i].x + pCube ->position.x ;
		pCube ->transformedVertices[i].y = pCube ->localVertices[i].y + pCube ->position.y ;
		pCube ->transformedVertices[i].z = pCube ->localVertices[i].z + pCube ->position.z ;
		pCube ->transformedVertices[i].w = pCube ->localVertices[i].w ;
	}
}

void RemoveBackface(PolySelfContained* polyList, int count, Vector3* pViewPortPosition)
{
	for (int i = 0; i < count; ++i)
	{
		Vector3 point0 ;
		point0.x = polyList[i].vertexList[0].x ;
		point0.y = polyList[i].vertexList[0].y ;
		point0.z = polyList[i].vertexList[0].z ;

		Vector3 point1 ;
		point1.x = polyList[i].vertexList[1].x ;
		point1.y = polyList[i].vertexList[1].y ;
		point1.z = polyList[i].vertexList[1].z ;

		Vector3 point2 ;
		point2.x = polyList[i].vertexList[2].x ;
		point2.y = polyList[i].vertexList[2].y ;
		point2.z = polyList[i].vertexList[2].z ;

		//	  1
		//	  /
		//	 /
		//	/
		// 0\
		//	 \
		//    \
		//     \
		//      2

		Vector3 u ;
		VectorMinusVector(&point1, &point0, &u) ;

		Vector3 v ;
		VectorMinusVector(&point2, &point0, &v) ;

		Vector3 n ;
		VectorCrossVector(&v, &u, &n) ;

		Vector3 view ;
		VectorMinusVector(pViewPortPosition, &point0, &view) ;

		float dotValue = VectorDotVector(&n, &view) ;

		if (dotValue <= 0)
			polyList[i].removed = true ;
		else
			polyList[i].removed = false ;
	}
}

void WorldToCamera(PolySelfContained* polyList, int count, Matrix4X4* pMatrix)
{
	Vector4 temp ;

	for (int i = 0; i < count; ++i)
	{
		if (polyList[i].removed)
			continue ;

		VectorMultMatrix(&polyList[i].vertexList[0], pMatrix, &temp) ;
		polyList[i].vertexList[0] = temp;

		VectorMultMatrix(&polyList[i].vertexList[1], pMatrix, &temp) ;
		polyList[i].vertexList[1]= temp ;

		VectorMultMatrix(&polyList[i].vertexList[2], pMatrix, &temp) ;
		polyList[i].vertexList[2] = temp ;
	}
}

void CameraToClip(PolySelfContained* polyList, int count, Matrix4X4* pMatrix)
{
	Vector4 temp ;

	for (int i = 0; i < count; ++i)
	{
		if (polyList[i].removed)
			continue ;

		VectorMultMatrix(&polyList[i].vertexList[0], pMatrix, &temp) ;
		polyList[i].vertexList[0] = temp ;

		VectorMultMatrix(&polyList[i].vertexList[1], pMatrix, &temp) ;
		polyList[i].vertexList[1]= temp ;

		VectorMultMatrix(&polyList[i].vertexList[2], pMatrix, &temp) ;
		polyList[i].vertexList[2] = temp ;
	}
}

void ClipToPerspective(PolySelfContained* polyList, int count, float nearDistance)
{
	for (int i = 0; i < count; ++i)
	{
		if (polyList[i].removed)
			continue ;

		float w = polyList[i].vertexList[0].w ;
		polyList[i].vertexList[0].x /= w ;
		polyList[i].vertexList[0].y /= w ;
		polyList[i].vertexList[0].z = nearDistance ;

		w = polyList[i].vertexList[1].w ;
		polyList[i].vertexList[1].x /= w ;
		polyList[i].vertexList[1].y /= w ;
		polyList[i].vertexList[1].z = nearDistance ;

		w = polyList[i].vertexList[2].w ;
		polyList[i].vertexList[2].x /= w ;
		polyList[i].vertexList[2].y /= w ;
		polyList[i].vertexList[2].z = nearDistance ;
	}
}

void CameraToperspective(PolySelfContained* polyList, int count, float viewPortWidth, float viewPortHeight, float fov)
{
	float viewDistance = (viewPortWidth - 1) / 2 / tan(fov / 2) ;

	Matrix4X4 projectionMatrix = {
		1, 0, 0, 0,
		0, 1, 0, 0,
		0, 0, 1, 1 / viewDistance,
		0, 0, 0, 0
	} ;

	Vector4 temp ;

	for (int i = 0; i < count; ++i)
	{
		if (polyList[i].removed)
			continue ;

		VectorMultMatrix(&polyList[i].vertexList[0], &projectionMatrix, &temp) ;
		polyList[i].vertexList[0] = temp ;
		polyList[i].vertexList[0].x /= polyList[i].vertexList[0].w ;
		polyList[i].vertexList[0].y /= polyList[i].vertexList[0].w ;
		polyList[i].vertexList[0].z /= polyList[i].vertexList[0].w ;

		VectorMultMatrix(&polyList[i].vertexList[1], &projectionMatrix, &temp) ;
		polyList[i].vertexList[1] = temp ;
		polyList[i].vertexList[1].x /= polyList[i].vertexList[1].w ;
		polyList[i].vertexList[1].y /= polyList[i].vertexList[1].w ;
		polyList[i].vertexList[1].z /= polyList[i].vertexList[1].w ;

		VectorMultMatrix(&polyList[i].vertexList[2], &projectionMatrix, &temp) ;
		polyList[i].vertexList[2] = temp ;
		polyList[i].vertexList[2].x /= polyList[i].vertexList[2].w ;
		polyList[i].vertexList[2].y /= polyList[i].vertexList[2].w ;
		polyList[i].vertexList[2].z /= polyList[i].vertexList[2].w ;
	}
}

void PerspectiveToScreen(PolySelfContained* polyList, int count, float viewPortWidth, float viewPortHeight)
{
	Vector4 temp ;

	for (int i = 0; i < count; ++i)
	{
		if (polyList[i].removed)
			continue ;

		//polyList[i].vertexList[0].x = viewPortWidth * (polyList[i].vertexList[0].x + 1) / 2 ;
		//polyList[i].vertexList[0].y = viewPortHeight * (polyList[i].vertexList[0].y + 1) / 2 ;

		//polyList[i].vertexList[1].x = viewPortWidth * (polyList[i].vertexList[1].x + 1) / 2 ;
		//polyList[i].vertexList[1].y = viewPortHeight * (polyList[i].vertexList[1].y + 1) / 2 ;

		//polyList[i].vertexList[2].x = viewPortWidth * (polyList[i].vertexList[2].x + 1) / 2 ;
		//polyList[i].vertexList[2].y = viewPortHeight * (polyList[i].vertexList[2].y + 1) / 2 ;

		polyList[i].vertexList[0].x = (polyList[i].vertexList[0].x + 1) * (viewPortWidth / 2 - 0.5) ;
		polyList[i].vertexList[0].y = (viewPortHeight - 1) - (polyList[i].vertexList[0].y + 1) * (viewPortHeight / 2 - 0.5) ;

		polyList[i].vertexList[1].x = (polyList[i].vertexList[1].x + 1) * (viewPortWidth / 2 - 0.5) ;
		polyList[i].vertexList[1].y = (viewPortHeight - 1) - (polyList[i].vertexList[1].y + 1) * (viewPortHeight / 2 - 0.5) ;

		polyList[i].vertexList[2].x = (polyList[i].vertexList[2].x + 1) * (viewPortWidth / 2 - 0.5) ;
		polyList[i].vertexList[2].y = (viewPortHeight - 1) - (polyList[i].vertexList[2].y + 1) * (viewPortHeight / 2 - 0.5) ;

		//temp.x = viewPortWidth / 2 - 0.5 + polyList[i].vertexList[0].x ;
		//temp.y = viewPortHeight / 2 - 0.5 - polyList[i].vertexList[0].y ;
		//temp.z = polyList[i].vertexList[0].z ;
		//temp.w = polyList[i].vertexList[0].w ;

		//polyList[i].vertexList[0] = temp ;

		//temp.x = viewPortWidth / 2 - 0.5 + polyList[i].vertexList[1].x ;
		//temp.y = viewPortHeight / 2 - 0.5 - polyList[i].vertexList[1].y ;
		//temp.z = polyList[i].vertexList[1].z ;
		//temp.w = polyList[i].vertexList[1].w ;

		//polyList[i].vertexList[1] = temp ;

		//temp.x = viewPortWidth / 2 - 0.5 + polyList[i].vertexList[2].x ;
		//temp.y = viewPortHeight / 2 - 0.5 - polyList[i].vertexList[2].y ;
		//temp.z = polyList[i].vertexList[2].z ;
		//temp.w = polyList[i].vertexList[2].w ;

		//polyList[i].vertexList[2] = temp ;
	}
}

C++游戏编程教程（三） Visual Studio 2022 C++游戏编程 c++游戏游戏开发 sdl 面向对象编程
在上一篇博客里，我们介绍了SDL基本的函数用法，今天，我们就来研究一下Game类的代码。让我们再次打开模板项目。注：在代码中，用到了一个头文件Math.h（不是C语言中的math.h），这是那本书的作者自己编写的一个头文件，非常有用，点击此处下载。一定要把解压后的Math.h和Math.cpp加入到项目里，才能编译通过。Game类代码先上代码：Game.h#pragmaonce#include"S
NOIP2017Day1T1-小凯的疑惑 Jack-Oran #基本数论（数学）NOIP
1．小凯的疑惑(math.cpp/c/pas)【问题描述】小凯手中有两种面值的金币，两种面值均为正整数且彼此互素。每种金币小凯都有无数个。在不找零的情况下，仅凭这两种金币，有些物品他是无法准确支付的。现在小凯想知道在无法准确支付的物品中，最贵的价值是多少金币？注意：输入数据保证存在小凯无法准确支付的商品。【输入格式】输入文件名为math.in。输入数据仅一行，包含两个正整数a和b，它们之间用一个空
NOIP2017小凯的疑惑 qyxpsx7 #复赛真题
小凯的疑惑(math.cpp/c/pas)【问题描述】小凯手中有两种面值的金币，两种面值均为正整数且彼此互素。每种金币小凯都有无数个。在不找零的情况下，仅凭这两种金币，有些物品他是无法准确支付的。现在小凯想知道在无法准确支付的物品中，最贵的价值是多少金币？注意：输入数据保证存在小凯无法准确支付的商品。【输入格式】两个正整数a和b，表示小凯手中金币的面值。【输出格式】一个正整数N，表示不找零的情况下
#20-【深搜】数独（math.cpp） 2017gdgzoi999 刷题模拟 DFS 搜索输入构造 gdgzoi刷题
DescriptionInput输入一共15行，包含一个新数独的实例。第奇数行包含左右方向的符号（），第偶数行包含上下方向的符号（^和v）。Output输出包含9行，每行9个1~9的数字，以单个空格隔开。输入保证解惟一。SampleInput>>>>v^^^^vvv^>>>>>>>^vvv^v^vv>>>>>v^^^^vvv^>>>>>>>^vvv^v^vv#defineSIZE10usingna
DLL文件的引用 dll
　　首先我们先要写一个DLL文件：　　　　我先创建一个win32的DLL工程，在工程中添加了Math.h和Math.cpp文件，具体内容如下： Math.h： #pragma once #include "stdafx.h" #ifdef API_EXPORT #define DLL_EXPORT _declspec(dllexport) #else #
用VC++创建可重用的Dll vc++
1.在VS中创建名为选择模版”Win32 Project” ，创建一个名为”Math”的项目： 2.在向导中，选择程序类型为”Dll”，附加选项为”Empty project”: 3.由于选择的是空项目，所以解决方案管理器中现在还没有任何代码文件。 4.手动添加两个文件：Math.h和Math.cpp，其中包含了一个一个类Math，一个全局函数Multiply()和一个全局变
第7周思考项目2分离三位数百位个位十位 MIKASA3 C++计算机科学
问题及代码：/* *Copyright(c)2014,烟台大学计算机与控制工程学院 *Allrightsreserved. *文件名称：math.cpp *作者：单昕昕 *完成日期：2014年10月10日 *版本号：v1.0 * *问题描述：输入一个三位数，分别输出它的百位十位个位 *输入描述：一个整数，是一个三位数 *程序输出：一个整数，代表三位数百位十位个位的值 */
Math.cpp Golden_Shadow
#include"Math.h" #include"Camera.h" Cube::Cube(floatx,floaty,floatz) { vertexCount=8; polyCount=12; position.x=x; position.y=y; position.z=z; floatscaler=0.2; localVertices[0].x=-50*scaler; localV
HQL之投影查询归来朝歌 HQL Hibernate 查询语句投影查询
在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
Spring整合redis bylijinnan redis
pom.xml <dependencies>  <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2 在项目中出现了org.hiber
android动画效果不懂事的小屁孩 android动画
前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
js delete 删除机理以及它的内存泄露问题的解决方案换个号韩国红果果 JavaScript
delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露（其实还未删除）举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
Oracle将零干预分析加入网络即服务计划蓝儿唯美 oracle
由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
spring学习——springmvc（二） a-john springMVC
Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
POJ-2828-Buy Tickets aijuans ACM_POJ
POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
Java Ant build.xml详解 asia007 build.xml
1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台 --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
android按钮监听器的四种技术百合不是茶 android xml配置监听器实现接口
android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方; 1,activity中使用内部类实现接口 ,创建内部类实例使用add方法与java类似创建监听器的实例 myLis lis = new myLis(); 使用add方法给按钮添加监听器
软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。如今很多的公司
TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForge How do Attachement Anchor Wiki Syntax
the CollabNet user information center http://help.collab.net/ How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
【Redis四】Redis数据类型 bit1129 redis
概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
SSH2整合-附源码白糖_ eclipse spring tomcat Hibernate Google
今天用eclipse终于整合出了struts2+hibernate+spring框架。我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。补充1：项目中部分jar包不是最新版的，可能导
[转]开源项目代码的学习方法 braveCS 学习方法
转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html 1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
编程之美-子数组的最大和（二维） bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
读书笔记-3 chengxuyuancsdn jquery笔记 resultMap配置 ibatis一对多配置
1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
[物理与天文]物理学新进展 comsci
如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境怎么办呢?
Oracle 11g新特性:Automatic Diagnostic Repository daizj oracle ADR
Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。这两份log文
简单排序:选择排序 dieslrae 选择排序
public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
线程同步工具类 shuizhaosi888 同步工具类
同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
bleeding edge是什么意思 haojinghua DI
不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。 In computer science, bleeding edge is a term that
c中实现utf8和gbk的互转 jimmee c iconv utf8&gbk编码
#include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
在代码中获取Android theme中的attr属性值 OliveExcel android theme
Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西. 在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
基于Zookeeper的分布式共享锁 roadrunners zookeeper 分布式共享锁
首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。官
两个容易被忽略的MySQL知识 tomcat_oracle mysql
1、varchar(5)可以存储多少个汉字，多少个字母数字？　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
zoj 3827 Information Entropy(水题) 阿尔萨斯 format
题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&

Math.cpp

你可能感兴趣的:(Math.cpp)