예제 #1
0
파일: MFString.cpp 프로젝트: TurkeyMan/fuji
int MFString::Enumerate(const MFArray<MFString> keys, bool bCaseSensitive)
{
	if(IsEmpty())
		return -1;
	for(size_t i=0; i<keys.size(); ++i)
	{
		if(bCaseSensitive ? Equals(keys[i]) : EqualsInsensitive(keys[i]))
			return (int)i;
	}
	return -1;
}
예제 #2
0
파일: main.cpp 프로젝트: FujiGameJam/fuji
void Game_Draw()
{
	if(!bShowModel)
	{
		MFView_SetOrtho();

		// draw model list
		if(models.size() > 0)
		{
			for(int a=0; a<(int)models.size(); ++a)
			{
				MFFont_DrawText2(MFFont_GetDebugFont(), 100.f, 100.f + (-menuIndex*20 + a*20), 20.f, a == menuIndex ? MFVector::yellow : MFVector::white, models[a].CStr());
			}
		}
		else
		{
			MFFont_DrawText2(MFFont_GetDebugFont(), 100.f, 100.f, 20.f, MFVector::red, "No models found!");
		}
	}
	else
	{
		if(pModel)
		{
			// set projection
			MFView_ConfigureProjection(MFDEGREES(60.f), 0.1f, 10000.f);
			MFView_SetAspectRatio(MFDisplay_GetNativeAspectRatio());
			MFView_SetProjection();

			// render the mesh
			MFRenderer_AddModel(pModel, NULL, MFView_GetViewState());
		}
		else
		{
			MFView_SetOrtho();
			MFFont_DrawText2(MFFont_GetDebugFont(), 100.f, 100.f, 20.f, MFVector::red, "Failed to load model!");
		}
	}
}
예제 #3
0
파일: ReadOBJ.cpp 프로젝트: TurkeyMan/fuji
void ParseOBJFile(const char *pFilePtr)
{
	const char *pToken = GetNextToken(pFilePtr);

	while(*pToken != 0)
	{
		if(!MFString_CaseCmp(pToken, "o"))
		{
			const char *pName = GetRestOfLine(pFilePtr);

			pModel->name = pName;
		}
		else if(!MFString_CaseCmp(pToken, "g"))
		{
			const char *pName = GetRestOfLine(pFilePtr);

			if(!vertsInGroup)
			{
				// we'll just rename the current subobject, since theres nothing in it..
				F3DSubObject &sub = pModel->GetMeshChunk()->subObjects[subObject];
				sub.name = pName;
			}
			else
			{
				// probably wanna copy vertex data in at this point..
				// and subtract the min from each of the components indices..
				CopyDataIntoSubobject(subObject);

				++subObject;

				matSub = 0;

				minVertIndex = -1;
				minUVIndex = -1;
				minNormIndex = -1;
				maxVertIndex = -1;
				maxUVIndex = -1;
				maxNormIndex = -1;

				vertsInGroup = false;
				vertsInMatSub = false;

				F3DSubObject &sub = pModel->GetMeshChunk()->subObjects[subObject];
				sub.name = pName;
			}
		}
		else if(!MFString_CaseCmp(pToken, "v"))
		{
			const char *pX = GetNextToken(pFilePtr);
			const char *pY = GetNextToken(pFilePtr);
			const char *pZ = GetNextToken(pFilePtr);
			pFilePtr = MFSeekNewline(pFilePtr);

			MFVector v;
			v.x = (float)atof(pX);
			v.y = (float)atof(pY);
			v.z = (float)atof(pZ);
			v.w = 1.0f;

			verts.push(v);
		}
		else if(!MFString_CaseCmp(pToken, "vt"))
		{
			const char *pU = GetNextToken(pFilePtr);
			const char *pV = GetNextToken(pFilePtr);
			pFilePtr = MFSeekNewline(pFilePtr);

			MFVector v;
			v.x = (float)atof(pU);
			v.y = (float)atof(pV);
			v.z = 0.0f;
			v.w = 1.0f;

			uvs.push(v);
		}
		else if(!MFString_CaseCmp(pToken, "vn"))
		{
			const char *pX = GetNextToken(pFilePtr);
			const char *pY = GetNextToken(pFilePtr);
			const char *pZ = GetNextToken(pFilePtr);
			pFilePtr = MFSeekNewline(pFilePtr);

			MFVector v;
			v.x = (float)atof(pX);
			v.y = (float)atof(pY);
			v.z = (float)atof(pZ);
			v.w = 1.0f;

			normals.push(v);
		}
		else if(!MFString_CaseCmp(pToken, "f"))
		{
			vertsInGroup = true;
			vertsInMatSub = true;

			F3DSubObject &sub = pModel->GetMeshChunk()->subObjects[subObject];

			const char *pRestOfLine = GetRestOfLine(pFilePtr);

			int firstVert = (int)sub.matSubobjects[matSub].vertices.size();

			pToken = GetNextToken(pRestOfLine);

			while(*pToken)
			{
				const char *pPos = GetNextIndex(pToken);
				const char *pUV = GetNextIndex(pToken);
				const char *pNorm = GetNextIndex(pToken);

				int posid = atoi(pPos);
				int texid = atoi(pUV);
				int normid = atoi(pNorm);

				if(posid < 0)
					posid = (int)verts.size() - posid;
				else
					posid = posid - 1;

				if(texid < 0)
					texid = (int)uvs.size() - texid;
				else
					texid = texid - 1;

				if(normid < 0)
					normid = (int)normals.size() - normid;
				else
					normid = normid - 1;

				minVertIndex = minVertIndex == -1 ? posid : MFMin(minVertIndex, posid);
				minUVIndex = minUVIndex == -1 ? texid : MFMin(minUVIndex, texid);
				minNormIndex = minNormIndex == -1 ? normid : MFMin(minNormIndex, normid);
				maxVertIndex = minVertIndex == -1 ? posid : MFMax(maxVertIndex, posid);
				maxUVIndex = maxUVIndex == -1 ? texid : MFMax(maxUVIndex, texid);
				maxNormIndex = maxNormIndex == -1 ? normid : MFMax(maxNormIndex, normid);

				int vi = (int)sub.matSubobjects[matSub].vertices.size();
				int f = vi - firstVert;

				F3DVertex &vert = sub.matSubobjects[matSub].vertices[firstVert + f];
				vert.position = posid;
				vert.uv[0] = texid;
				vert.normal = normid;

				// add a triangle if we are up to the third vert or beyond
				if(f >= 2)
				{
					F3DTriangle &tri = sub.matSubobjects[matSub].triangles.push();

					tri.v[0] = firstVert;
					tri.v[1] = vi-1;
					tri.v[2] = vi;
				}

				pToken = GetNextToken(pRestOfLine);
			}
		}
		else if(!MFString_CaseCmp(pToken, "usemtl"))
		{
			F3DSubObject &sub = pModel->GetMeshChunk()->subObjects[subObject];

			if(vertsInGroup && vertsInMatSub)
			{
				++matSub;
				vertsInMatSub = false;
			}

			const char *pName = GetRestOfLine(pFilePtr);

			sub.matSubobjects[matSub].materialIndex = GetMaterialID(pName);
		}
		else if(!MFString_CaseCmp(pToken, "mtllib"))
		{
			// load material info?
			//..
			
			pFilePtr = MFSeekNewline(pFilePtr);
		}
		else if(pToken[0] == '#')
		{
			pFilePtr = MFSeekNewline(pFilePtr);
		}
		else
		{
			MFDebug_Warn(2, MFStr("Unknown token encountered in obj file '%s'!", pToken));
			pFilePtr = MFSeekNewline(pFilePtr);
		}

		pToken = GetNextToken(pFilePtr);
	}

	// want to copy vertex data into the last subobject at this point...
	if(vertsInGroup)
	{
		CopyDataIntoSubobject(subObject);
	}
}
예제 #4
0
파일: main.cpp 프로젝트: FujiGameJam/fuji
void Game_Update()
{
	if(!bShowModel)
	{
		if(MFInput_WasPressed(Key_Up, IDD_Keyboard) && menuIndex > 0)
			--menuIndex;
		else if(MFInput_WasPressed(Key_Down, IDD_Keyboard) && menuIndex < (int)models.size()-1)
			++menuIndex;
		else if(MFInput_WasPressed(Key_Return, IDD_Keyboard) && models.size() > 0)
		{
			bShowModel = true;

			// load model
			pModel = MFModel_CreateWithAnimation(models[menuIndex].CStr());
		}
	}
	else
	{
		if(MFInput_WasPressed(Key_Escape, IDD_Keyboard))
		{
			if(pModel)
			{
				MFModel_Destroy(pModel);
				pModel = NULL;
			}

			models.clear();
			Scan("data:");

			if(models.size() <= (size_t)menuIndex)
				menuIndex = models.size() ? (int)models.size() - 1 : 0;
			bShowModel = false;
			return;
		}

		if(pModel)
		{
			if(MFInput_Read(Mouse_LeftButton, IDD_Mouse) > 0.f)
			{
				yaw += -MFInput_Read(Mouse_XDelta, IDD_Mouse) * 0.02f;
				pitch += -MFInput_Read(Mouse_YDelta, IDD_Mouse) * 0.015f;
			}
			if(MFInput_Read(Mouse_MiddleButton, IDD_Mouse) > 0.f)
			{
				zoom *= 1.f + -MFInput_Read(Mouse_YDelta, IDD_Mouse) * 0.02f;
			}

			// calculate a spinning world matrix
			MFMatrix world;
			world.SetTranslation(MakeVector(0, -0.25f, 1) * zoom);
			world.RotateY(yaw);
			world.RotateX(pitch);

			// set world matrix to the model
			MFModel_SetWorldMatrix(pModel, world);

			// advance the animation
			MFAnimation *pAnim = MFModel_GetAnimation(pModel);
			if(pAnim)
			{
				float start, end;
				MFAnimation_GetFrameRange(pAnim, &start, &end);
	
				static float time = 0.f;
				time += MFSystem_TimeDelta();// * 500;
				while(time >= end)
					time -= end;
				MFAnimation_SetFrame(pAnim, time);
			}
		}
	}
}
예제 #5
0
void LoadTextXFile(const char *pText)
{
	const char *pTok = GetNextToken(pText, &pText);

	while(pTok)
	{
		if(!MFString_Compare(pTok, "Header"))
		{
			SkipToken(pText, "{");

			int maj = GetInt(pText, &pText);
			int min = GetInt(pText, &pText);
			int flag = GetInt(pText, &pText);

//			printf("XFile V%d.%d, 0x%X\n", maj, min, flag);

			pTok = GetNextToken(pText, &pText);
			while(MFString_Compare(pTok, "}"))
			{
				pTok = GetNextToken(pText, &pText);
			}
		}
		else if(!MFString_Compare(pTok, "Frame"))
		{
			pText = ParseFrame(pText, MFMatrix::identity, -1);
		}
		else if(!MFString_Compare(pTok, "Mesh"))
		{
			gMeshChunks.push(XMeshChunk::Create(MFMatrix::identity, pText, ""));
			SkipSection(pText);
		}
		else if(!MFString_Compare(pTok, "AnimationSet"))
		{
			gAnimSets.push(pText);
			SkipSection(pText);
		}
		else if(!MFString_Compare(pTok, "template"))
		{
//			const char *pName = GetNextToken(pText, &pText);
			SkipSection(pText);
		}
		else
		{
			MFDebug_Warn(4, MFStr("Unknown token '%s'\n", pTok));
			SkipSection(pText);
		}

		pTok = GetNextToken(pText, &pText);
	}

	int a;
	for(a=0; a<gMeshChunks.size(); a++)
	{
		ParseMesh(gMeshChunks[a].pMesh, gMeshChunks[a].mat, gMeshChunks[a].frameName);
	}

	for(a=0; a<gAnimSets.size(); a++)
	{
		ParseAnimationSet(gAnimSets[a]);
	}

	gMeshChunks.clear();
}