コード例 #1
0
void CRenderingContext::RenderText(const tstring& sText, unsigned iLength, FTFont* pFont)
{
	TAssert(m_pShader);
	if (!m_pShader)
		return;

	CRenderContext& oContext = GetContext();

	if (iLength == -1)
		iLength = sText.length();

	TAssert(m_pShader->m_iPositionAttribute >= 0);
	TAssert(m_pShader->m_aiTexCoordAttributes[0] >= 0);

	if (!oContext.m_bProjectionUpdated)
		SetUniform("mProjection", oContext.m_mProjection);

	if (!oContext.m_bViewUpdated)
		SetUniform("mView", oContext.m_mView);

	// Take the position out and let FTGL do it. It looks sharper that way.
	Matrix4x4 mTransformations = oContext.m_mTransformations;
	Vector vecPosition = mTransformations.GetTranslation();
	mTransformations.SetTranslation(Vector());
	SetUniform("mGlobal", mTransformations);

	oContext.m_bProjectionUpdated = oContext.m_bViewUpdated = oContext.m_bTransformUpdated = true;

	ftglSetAttributeLocations(m_pShader->m_iPositionAttribute, m_pShader->m_aiTexCoordAttributes[0]);

	pFont->Render(sText.c_str(), iLength, FTPoint(vecPosition.x, vecPosition.y, vecPosition.z));
}
コード例 #2
0
void ResizeMap(FileMappingInfo* mapping_info, size_t minimum_size)
{
	munmap(mapping_info->m_memory, mapping_info->m_memory_size);

	struct stat file_statbuf;

	fstat(mapping_info->m_file_handle, &file_statbuf);
	int file_size = file_statbuf.st_size;

	// I'm not sure this will ever happen. If years go by and this assert is
	// never hit then the fstat and the next tmax below can be removed.
	TAssert(file_size <= minimum_size);

	minimum_size = tmax(minimum_size, file_size);

	int page_size = sysconf(_SC_PAGESIZE);
	int remainder = stb_mod_eucl(minimum_size, page_size);
	int aligned_size;
	if (remainder)
		aligned_size = minimum_size - stb_mod_eucl(minimum_size, page_size) + page_size;
	else
		aligned_size = tmax(minimum_size, page_size);

	int truncated = ftruncate(mapping_info->m_file_handle, aligned_size);
	TAssert(truncated == 0);

	mapping_info->m_memory_size = aligned_size;
	mapping_info->m_memory = mmap(nullptr, aligned_size, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, mapping_info->m_file_handle, 0);
}
コード例 #3
0
void CRenderingContext::SetPositionBuffer(size_t iOffset, size_t iStride)
{
	TAssert(iOffset%4 == 0);	// Should be multiples of four because it's offsets in bytes and we're always working with floats or doubles
	TAssert(m_pShader->m_iPositionAttribute != ~0);
	glEnableVertexAttribArray(m_pShader->m_iPositionAttribute);
	glVertexAttribPointer(m_pShader->m_iPositionAttribute, 3, GL_FLOAT, false, iStride, BUFFER_OFFSET(iOffset));
}
コード例 #4
0
	virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult, bool normalInWorldSpace)
	{
		if (!m_pController->IsColliding())
			return 1;

		if (convexResult.m_hitCollisionObject == m_me)
			return btScalar(1.0);

		if (convexResult.m_hitCollisionObject->getBroadphaseHandle()->m_collisionFilterGroup & CG_TRIGGER)
			return 1;

		if (!convexResult.m_hitCollisionObject->hasContactResponse())
			return btScalar(1.0);

		if ((size_t)convexResult.m_hitCollisionObject->getUserPointer() >= GameServer()->GetMaxEntities())
		{
			size_t iIndex = (size_t)convexResult.m_hitCollisionObject->getUserPointer() - GameServer()->GetMaxEntities();
			CBaseEntity* pControllerEntity = m_pController->GetEntity();
			TAssert(pControllerEntity);
			if (pControllerEntity)
			{
				TAssert(normalInWorldSpace);
				if (!pControllerEntity->ShouldCollideWithExtra(iIndex, Vector(convexResult.m_hitPointLocal)))
					return 1;
			}
		}
		else
		{
			CEntityHandle<CBaseEntity> hCollidedEntity((size_t)convexResult.m_hitCollisionObject->getUserPointer());
			TAssert(hCollidedEntity != NULL);
			if (hCollidedEntity.GetPointer())
			{
				CBaseEntity* pControllerEntity = m_pController->GetEntity();
				TAssert(pControllerEntity);
				if (pControllerEntity)
				{
					TAssert(normalInWorldSpace);
					if (!pControllerEntity->ShouldCollideWith(hCollidedEntity, Vector(convexResult.m_hitPointLocal)))
						return 1;
				}
			}
		}

		btVector3 hitNormalWorld;
		if (normalInWorldSpace)
		{
			hitNormalWorld = convexResult.m_hitNormalLocal;
		} else
		{
			///need to transform normal into worldspace
			hitNormalWorld = convexResult.m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
		}

		btScalar dotUp = m_up.dot(hitNormalWorld);
		if (dotUp < 0)
			return btScalar(1.0);

		return ClosestConvexResultCallback::addSingleResult (convexResult, normalInWorldSpace);
	}
コード例 #5
0
void CRenderingContext::CreateVBO(size_t& iVBO, size_t& iVBOSize)
{
	TAssert(m_pRenderer);
	if (!m_pRenderer)
		return;

	TAssert(s_avecVertices.size());
	if (!s_avecVertices.size())
		return;

	TAssert(m_iDrawMode == GL_TRIANGLES);

	size_t iDataSize = 0;
	iDataSize += s_avecVertices.size()*3;

	for (size_t i = 0; i < s_aavecTexCoords.size(); i++)
		iDataSize += s_aavecTexCoords[i].size()*2;

	iDataSize += s_avecNormals.size()*3;

	tvector<float> aflData;
	aflData.reserve(iDataSize);

	TAssert(!s_avecNormals.size() || s_avecVertices.size() == s_avecNormals.size());
	for (size_t i = 0; i < s_aavecTexCoords.size(); i++)
		TAssert(!s_aavecTexCoords[i].size() || s_avecVertices.size() == s_aavecTexCoords[i].size());

	for (size_t i = 0; i < s_avecVertices.size(); i++)
	{
		Vector& vecVert = s_avecVertices[i];
		aflData.push_back(vecVert.x);
		aflData.push_back(vecVert.y);
		aflData.push_back(vecVert.z);

		if (s_avecNormals.size())
		{
			Vector& vecNormal = s_avecNormals[i];
			aflData.push_back(vecNormal.x);
			aflData.push_back(vecNormal.y);
			aflData.push_back(vecNormal.z);
		}

		for (size_t j = 0; j < s_aavecTexCoords.size(); j++)
		{
			if (s_aavecTexCoords[j].size())
			{
				Vector2D& vecUV = s_aavecTexCoords[j][i];
				aflData.push_back(vecUV.x);
				aflData.push_back(vecUV.y);
			}
		}
	}

	iVBO = m_pRenderer->LoadVertexDataIntoGL(aflData.size()*sizeof(float), aflData.data());
	iVBOSize = s_avecVertices.size();
}
コード例 #6
0
void CRenderingContext::SetTexCoordBuffer(size_t iOffset, size_t iStride, size_t iChannel)
{
	TAssert(iChannel >= 0 && iChannel < MAX_TEXTURE_CHANNELS);

	if (m_pShader->m_aiTexCoordAttributes[iChannel] == ~0)
		return;

	TAssert(iOffset%4 == 0);	// Should be multiples of four because it's offsets in bytes and we're always working with floats or doubles
	glEnableVertexAttribArray(m_pShader->m_aiTexCoordAttributes[iChannel]);
	glVertexAttribPointer(m_pShader->m_aiTexCoordAttributes[iChannel], 2, GL_FLOAT, false, iStride, BUFFER_OFFSET(iOffset));
}
コード例 #7
0
ファイル: shaders.cpp プロジェクト: BSVino/LunarWorkshop
size_t CShaderLibrary::GetProgram(const tstring& sName)
{
	TAssert(Get());
	if (!Get())
		return 0;

	TAssert(Get()->GetShader(sName));
	if (!Get()->GetShader(sName))
		return 0;

	return Get()->GetShader(sName)->m_iProgram;
}
コード例 #8
0
void CRenderingContext::SetCustomIntBuffer(const char* pszName, size_t iSize, size_t iOffset, size_t iStride)
{
	int iAttribute = glGetAttribLocation(m_iProgram, pszName);

	TAssert(iAttribute != ~0);
	if (iAttribute == ~0)
		return;

	TAssert(iOffset%4 == 0);	// Should be multiples of four because it's offsets in bytes and we're always working with floats or doubles
	glEnableVertexAttribArray(iAttribute);
	glVertexAttribIPointer(iAttribute, iSize, GL_INT, iStride, BUFFER_OFFSET(iOffset));
}
コード例 #9
0
ファイル: trees.cpp プロジェクト: BSVino/CodenameInfinite
DoubleVector CTreeManager::GetTreeOrigin(const CTreeAddress& oAddress) const
{
	TAssert(oAddress.IsValid());
	if (!oAddress.IsValid())
		return DoubleVector();

	const CChunkTrees* pChunkTrees = GetChunkTrees(oAddress.iTerrain, oAddress.vecMin);

	TAssert(pChunkTrees);
	if (!pChunkTrees)
		return DoubleVector();

	return pChunkTrees->GetTreeOrigin(oAddress.iTree);
}
コード例 #10
0
void CALLBACK GLDebugCallback(GLenum iSource, GLenum iType, GLuint id, GLenum iSeverity, GLsizei iLength, const GLchar* pszMessage, GLvoid* pUserParam)
{
	if (iType != GL_DEBUG_TYPE_PERFORMANCE_ARB)
	{
		TAssert(iSeverity != GL_DEBUG_SEVERITY_HIGH_ARB);
		TAssert(iSeverity != GL_DEBUG_SEVERITY_MEDIUM_ARB);
	}

	if (gl_debug.GetBool())
	{
		tstring sMessage = "OpenGL Debug Message (";

		if (iSource == GL_DEBUG_SOURCE_API_ARB)
			sMessage += "Source: API ";
		else if (iSource == GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB)
			sMessage += "Source: Window System ";
		else if (iSource == GL_DEBUG_SOURCE_SHADER_COMPILER_ARB)
			sMessage += "Source: Shader Compiler ";
		else if (iSource == GL_DEBUG_SOURCE_THIRD_PARTY_ARB)
			sMessage += "Source: Third Party ";
		else if (iSource == GL_DEBUG_SOURCE_APPLICATION_ARB)
			sMessage += "Source: Application ";
		else if (iSource == GL_DEBUG_SOURCE_OTHER_ARB)
			sMessage += "Source: Other ";

		if (iType == GL_DEBUG_TYPE_ERROR_ARB)
			sMessage += "Type: Error ";
		else if (iType == GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB)
			sMessage += "Type: Deprecated Behavior ";
		else if (iType == GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB)
			sMessage += "Type: Undefined Behavior ";
		else if (iType == GL_DEBUG_TYPE_PORTABILITY_ARB)
			sMessage += "Type: Portability ";
		else if (iType == GL_DEBUG_TYPE_PERFORMANCE_ARB)
			sMessage += "Type: Performance ";
		else if (iType == GL_DEBUG_TYPE_OTHER_ARB)
			sMessage += "Type: Other ";

		if (iSeverity == GL_DEBUG_SEVERITY_HIGH_ARB)
			sMessage += "Severity: High) ";
		else if (iSeverity == GL_DEBUG_SEVERITY_MEDIUM_ARB)
			sMessage += "Severity: Medium) ";
		else if (iSeverity == GL_DEBUG_SEVERITY_LOW_ARB)
			sMessage += "Severity: Low) ";

		sMessage += convertstring<GLchar, tchar>(pszMessage) + "\n";

		TMsg(convertstring<GLchar, tchar>(sMessage).c_str());
	}
}
コード例 #11
0
ファイル: trees.cpp プロジェクト: BSVino/CodenameInfinite
void CTreeManager::RemoveTree(const CTreeAddress& oAddress)
{
	TAssert(oAddress.IsValid());
	if (!oAddress.IsValid())
		return;

	CChunkTrees* pChunkTrees = GetChunkTrees(oAddress.iTerrain, oAddress.vecMin);

	TAssert(pChunkTrees);
	if (!pChunkTrees)
		return;

	pChunkTrees->RemoveTree(oAddress.iTree);
}
コード例 #12
0
ファイル: ao.cpp プロジェクト: ezhangle/SMAK
bool CAOGenerator::Texel(size_t w, size_t h, size_t& iTexel, bool bUseMask)
{
    if (w < 0 || h < 0 || w >= m_iWidth || h >= m_iHeight)
        return false;

    TAssert(m_iHeight == m_iWidth); // This formula is actually wrong unless the thing is a perfect square
    iTexel = m_iHeight*(m_iHeight-h-1) + w;

    TAssert(iTexel >= 0 && iTexel < m_iWidth * m_iHeight);

    if (bUseMask && !m_bPixelMask[iTexel])
        return false;

    return true;
}
コード例 #13
0
ファイル: toy_util.cpp プロジェクト: BSVino/Digitanks
void CToyUtil::AddSceneAreaVisible(size_t iSceneArea, size_t iVisible)
{
	TAssert(iSceneArea < m_asSceneAreas.size());
	if (iSceneArea >= m_asSceneAreas.size())
		return;

	TAssert(iVisible < m_asSceneAreas.size());
	if (iVisible >= m_asSceneAreas.size())
		return;

	if (IsVisibleFrom(iSceneArea, iVisible))
		return;

	m_asSceneAreas[iSceneArea].m_aiVisibleAreas.push_back(iVisible);
}
コード例 #14
0
ファイル: crunch.cpp プロジェクト: BSVino/SMAK
bool CTexelGenerator::Texel(size_t w, size_t h, size_t& iTexel, size_t tw, size_t th, bool* abMask)
{
	if (w < 0 || h < 0 || w >= tw || h >= th)
		return false;

	TAssert(tw == th); // This formula is actually wrong unless the thing is a perfect square
	iTexel = th*(th-h-1) + w;

	TAssert(iTexel >= 0 && iTexel < tw * th);

	if (abMask && !abMask[iTexel])
		return false;

	return true;
}
コード例 #15
0
ファイル: structure.cpp プロジェクト: BSVino/CodenameInfinite
void CStructure::SetPhysicsTransform(const Matrix4x4& m)
{
	CPlanet* pPlanet = GameData().GetPlanet();
	if (!pPlanet)
	{
		SetLocalTransform(TMatrix(m));
		return;
	}

	if (!pPlanet->GetChunkManager()->HasGroupCenter())
	{
		SetLocalTransform(TMatrix(m));
		return;
	}

	GameData().SetGroupTransform(m);

	TMatrix mLocalTransform(pPlanet->GetChunkManager()->GetGroupCenterToPlanetTransform() * m);

	CBaseEntity* pMoveParent = GetMoveParent();
	TAssert(pMoveParent);
	if (pMoveParent)
	{
		while (pMoveParent != pPlanet)
		{
			mLocalTransform = pMoveParent->GetLocalTransform().InvertedRT() * mLocalTransform;
			pMoveParent = pMoveParent->GetMoveParent();
		}
	}

	SetLocalTransform(mLocalTransform);
}
コード例 #16
0
void CRenderingContext::RenderBillboard(const CMaterialHandle& hMaterial, float flRadius, Vector vecUp, Vector vecRight)
{
	TAssert(hMaterial.IsValid());
	if (!hMaterial.IsValid())
		return;

	vecUp *= flRadius;
	vecRight *= flRadius;

	// Clear out any existing rotation so that they don't interfere with the billboarding below.
	GetContext().m_mTransformations.SetAngles(EAngle(0, 0, 0));
	GetContext().m_bTransformUpdated = false;

	if (GetContext().m_hMaterial != hMaterial)
		UseMaterial(hMaterial);

	BeginRenderTriFan();
		TexCoord(0.0f, 1.0f);
		Vertex(-vecRight + vecUp);
		TexCoord(0.0f, 0.0f);
		Vertex(-vecRight - vecUp);
		TexCoord(1.0f, 0.0f);
		Vertex(vecRight - vecUp);
		TexCoord(1.0f, 1.0f);
		Vertex(vecRight + vecUp);
	EndRender();
}
コード例 #17
0
ファイル: trees.cpp プロジェクト: BSVino/CodenameInfinite
CChunkTrees* CTreeManager::AddChunkTrees(size_t iTerrain, const DoubleVector2D& vecMin)
{
	CChunkAddress oChunkAddress;
	oChunkAddress.iTerrain = iTerrain;
	oChunkAddress.vecMin = vecMin;

	CTerrainChunk* pTheChunkWereLookingFor = nullptr;
	for (size_t i = 0; i < m_pPlanet->GetChunkManager()->GetNumChunks(); i++)
	{
		CTerrainChunk* pChunk = m_pPlanet->GetChunkManager()->GetChunk(i);
		if (!pChunk)
			continue;

		if (pChunk->GetTerrain() != iTerrain)
			continue;

		if (pChunk->GetMin2D() != vecMin)
			continue;

		pTheChunkWereLookingFor = pChunk;
		break;
	}

	TAssert(pTheChunkWereLookingFor);

	DoubleMatrix4x4 mChunk;
	if (pTheChunkWereLookingFor)
		mChunk = pTheChunkWereLookingFor->GetChunkToPlanet();

	return &m_aChunkTrees.insert(tpair<CChunkAddress, CChunkTrees>(oChunkAddress, CChunkTrees(this, mChunk))).first->second;
}
コード例 #18
0
ファイル: editorpanel.cpp プロジェクト: BSVino/LunarWorkshop
void CEditorPanel::TargetEntityChangedCallback(const tstring& sArgs)
{
    CLevel* pLevel = LevelEditor()->GetLevel();
    if (!pLevel)
        return;

    auto pOutput = GetCurrentOutput();
    if (!pOutput)
        return;

    pOutput->m_sTargetName = m_hOutputEntityNameText->GetText();

    tvector<tstring> asTargets;

    for (size_t i = 0; i < pLevel->GetEntityData().size(); i++)
    {
        auto* pEntity = &pLevel->GetEntityData()[i];
        if (!pEntity)
            continue;

        if (!pEntity->GetName().length())
            continue;

        CEntityRegistration* pRegistration = CBaseEntity::GetRegisteredEntity("C"+pEntity->GetClass());
        TAssert(pRegistration);
        if (!pRegistration)
            continue;

        asTargets.push_back(pEntity->GetName());
    }

    m_hOutputEntityNameText->SetAutoCompleteCommands(asTargets);

    LayoutInput();
}
コード例 #19
0
ファイル: toy_util.cpp プロジェクト: BSVino/Digitanks
size_t CToyUtil::AddSceneArea(const tstring& sFileName)
{
	CToy* pArea = new CToy();
	bool bRead = CToyUtil::Read(GetGameDirectory() + T_DIR_SEP + sFileName, pArea);

	if (!bRead)
	{
		delete pArea;

		TAssert(bRead);
		TError("Couldn't find scene area " + sFileName + "\n");

		return ~0;
	}

	CSceneArea& oSceneArea = m_asSceneAreas.push_back();

	oSceneArea.m_sFileName = sFileName;
	oSceneArea.m_aabbArea = pArea->GetVisBounds();

	// I'm visible to myself.
	oSceneArea.m_aiNeighboringAreas.push_back(m_asSceneAreas.size()-1);

	delete pArea;

	return m_asSceneAreas.size()-1;
}
コード例 #20
0
ファイル: gameserver.cpp プロジェクト: BSVino/LunarWorkshop
CGameServer::~CGameServer()
{
	GameNetwork()->SetCallbacks(NULL, NULL, NULL, NULL);

	if (m_pWorkListener)
		m_pWorkListener->BeginProgress();

	if (m_pWorkListener)
		m_pWorkListener->SetAction("Scrubbing database", CBaseEntity::GetEntityRegistration().size());

	DestroyAllEntities(tvector<tstring>());

	GamePhysics()->RemoveAllEntities();

	for (size_t i = 0; i < m_apLevels.size(); i++)
		m_apLevels[i].reset();

	if (m_pCameraManager)
		delete m_pCameraManager;

	if (m_pWorkListener)
		m_pWorkListener->EndProgress();

	TAssert(s_pGameServer == this);
	s_pGameServer = NULL;
}
コード例 #21
0
ファイル: ioctl.c プロジェクト: kcrazy/winekit
NTSTATUS INTERNAL
ReadReport(
    __in  PDEVICE_EXTENSION DevExt,
    __in  PIRP              Irp,
    __out BOOLEAN           *fSentDown
    )
{
    NTSTATUS status;
    PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(Irp);
    ULONG DataLen = irpsp->Parameters.DeviceIoControl.OutputBufferLength;

    TEnter(Func, ("(DevExt=%p,Irp=%p,IrpSp=%p)", DevExt, Irp, irpsp));
    TAssert(Irp->UserBuffer != NULL);
    if (DataLen != sizeof(HID_INPUT_REPORT))
    {
        status = STATUS_INVALID_BUFFER_SIZE;
        LogError(ERRLOG_INVALID_BUFFER_SIZE,
                 status,
                 UNIQUE_ERRID(0x60),
                 NULL,
                 NULL);
        TWarn(("Invalid input report size (len=%d,Expected=%d).",
               DataLen, sizeof(HID_INPUT_REPORT)));
    }
    else
    {
        status = OemReadReport(DevExt, Irp, fSentDown);
    }

    TExit(Func, ("=%x", status));
    return status;
}       //ReadReport
コード例 #22
0
ファイル: lobbyui.cpp プロジェクト: BSVino/Digitanks
void CLobbyPanel::BeginGameCallback(int iConnection, INetworkListener*, class CNetworkParameters*)
{
	TAssert(iConnection == CONNECTION_LOBBY);

	CDigitanksLevel* pLevel = CDigitanksGame::GetLevel(CGameLobbyClient::L_GetInfoValue(_T("level_file")));
	if (!pLevel)
		return;

	CVar::SetCVar(_T("game_level"), pLevel->GetFile());

	DigitanksWindow()->GetLobbyPanel()->SetVisible(false);

	const char* pszPort = DigitanksWindow()->GetCommandLineSwitchValue("--port");
	int iPort = pszPort?atoi(pszPort):0;

	if (LobbyNetwork()->IsHost())
		GameNetwork()->CreateHost(iPort);
	else
		GameNetwork()->ConnectToHost(convertstring<tchar, char>(DigitanksWindow()->GetLobbyPanel()->m_sHost).c_str(), iPort);

	if (GameNetwork()->IsConnected())
		DigitanksWindow()->Restart(GAMETYPE_FROM_LOBBY);
	else
		DigitanksWindow()->Restart(GAMETYPE_MENU);
}
コード例 #23
0
void CReflectionProxy::Spawn()
{
	TAssert(!s_pProxy);
	s_pProxy = this;

	BaseClass::Spawn();
}
コード例 #24
0
void Matrix4x4::SetRotation(float flAngle, const Vector& v)
{
	// Normalize beforehand
	TAssert(fabs(v.LengthSqr() - 1) < 0.000001f);

	// c = cos(angle), s = sin(angle), t = (1-c)
	// [ xxt+c   xyt-zs  xzt+ys ]
	// [ yxt+zs  yyt+c   yzt-xs ]
	// [ zxt-ys  zyt+xs  zzt+c  ]

	float x = v.x;
	float y = v.y;
	float z = v.z;

	float c = cos(flAngle*(float)M_PI/180);
	float s = sin(flAngle*(float)M_PI/180);
	float t = 1-c;

	m[0][0] = x*x*t + c;
	m[1][0] = x*y*t - z*s;
	m[2][0] = x*z*t + y*s;

	m[0][1] = y*x*t + z*s;
	m[1][1] = y*y*t + c;
	m[2][1] = y*z*t - x*s;

	m[0][2] = z*x*t - y*s;
	m[1][2] = z*y*t + x*s;
	m[2][2] = z*z*t + c;
}
コード例 #25
0
ファイル: toyeditor.cpp プロジェクト: BSVino/CodenameInfinite
void CToyEditor::ManipulatorUpdated(const tstring& sArguments)
{
	// Grab this before GetToyToModify since that does a layout and clobbers the list.
	size_t iSelected = m_pSourcePanel->m_pPhysicsShapes->GetSelectedNodeId();

	tvector<tstring> asTokens;
	strtok(sArguments, asTokens);
	TAssert(asTokens.size() == 2);
	TAssert(stoi(asTokens[1]) == iSelected);
	TAssert(iSelected != ~0);

	if (iSelected >= ToyEditor()->GetToy().m_aShapes.size())
		return;

	ToyEditor()->GetToyToModify().m_aShapes[iSelected].m_trsTransform = Manipulator()->GetTRS();
}
コード例 #26
0
ファイル: toy.cpp プロジェクト: BSVino/CodenameInfinite
Vector CToy::GetPhysicsBoxHalfSize(size_t iBox)
{
	TRS& trs = GetPhysicsBox(iBox);

	TAssert(trs.m_angRotation.p == 0);
	TAssert(trs.m_angRotation.y == 0);
	TAssert(trs.m_angRotation.r == 0);

	Matrix4x4 mTRS = trs.GetMatrix4x4();

	AABB aabbBox = s_aabbBoxDimensions;
	aabbBox.m_vecMins = mTRS*aabbBox.m_vecMins;
	aabbBox.m_vecMaxs = mTRS*aabbBox.m_vecMaxs;

	return aabbBox.m_vecMaxs - aabbBox.Center();
}
コード例 #27
0
ファイル: renderingcontext.cpp プロジェクト: BSVino/SMAK
void CRenderingContext::EndRender()
{
	TAssert(m_pShader);
	if (!m_pShader)
	{
		UseProgram("model");
		if (!m_pShader)
			return;
	}

	SetUniform("mProjection", GetContext().m_mProjection);
	SetUniform("mView", GetContext().m_mView);
	SetUniform("mGlobal", GetContext().m_mTransformations);

	if (m_bTexCoord && m_pShader->m_iTexCoordAttribute != ~0)
	{
		glEnableVertexAttribArray(m_pShader->m_iTexCoordAttribute);
		glVertexAttribPointer(m_pShader->m_iTexCoordAttribute, 2, GL_FLOAT, false, 0, m_aavecTexCoords[0].data());
	}

	if (m_bNormal && m_pShader->m_iNormalAttribute != ~0)
	{
		glEnableVertexAttribArray(m_pShader->m_iNormalAttribute);
		glVertexAttribPointer(m_pShader->m_iNormalAttribute, 3, GL_FLOAT, false, 0, m_avecNormals.data());
	}

	if (m_bColor && m_pShader->m_iColorAttribute != ~0)
	{
		glEnableVertexAttribArray(m_pShader->m_iColorAttribute);
		glVertexAttribPointer(m_pShader->m_iColorAttribute, 3, GL_UNSIGNED_BYTE, true, sizeof(::Color), m_aclrColors.data());
	}

	TAssert(m_pShader->m_iPositionAttribute != ~0);
	glEnableVertexAttribArray(m_pShader->m_iPositionAttribute);
	glVertexAttribPointer(m_pShader->m_iPositionAttribute, 3, GL_FLOAT, false, 0, m_avecVertices.data());

	glDrawArrays(m_iDrawMode, 0, m_avecVertices.size());

	glDisableVertexAttribArray(m_pShader->m_iPositionAttribute);
	if (m_pShader->m_iTexCoordAttribute != ~0)
		glDisableVertexAttribArray(m_pShader->m_iTexCoordAttribute);
	if (m_pShader->m_iNormalAttribute != ~0)
		glDisableVertexAttribArray(m_pShader->m_iNormalAttribute);
	if (m_pShader->m_iColorAttribute != ~0)
		glDisableVertexAttribArray(m_pShader->m_iColorAttribute);
}
コード例 #28
0
ファイル: trees.cpp プロジェクト: BSVino/CodenameInfinite
void CChunkTrees::Load()
{
	TAssert(m_pManager->m_pPlanet->GetChunkManager()->HasGroupCenter());
	TAssert(m_avecOrigins.size());
	TAssert(!m_aiPhysicsBoxes.size());

	DoubleMatrix4x4 mPlanetToGroup = m_pManager->m_pPlanet->GetChunkManager()->GetPlanetToGroupCenterTransform();

	float flScale = (float)CScalableFloat::ConvertUnits(1, m_pManager->m_pPlanet->GetScale(), SCALE_METER);

	for (size_t i = 0; i < m_avecOrigins.size(); i++)
	{
		size_t iPhysicsBox = GamePhysics()->AddExtraBox(mPlanetToGroup * (m_avecOrigins[i]*flScale), Vector(1, 5, 1));

		m_aiPhysicsBoxes.push_back(iPhysicsBox);
	}
}
コード例 #29
0
ファイル: trees.cpp プロジェクト: BSVino/CodenameInfinite
DoubleVector CChunkTrees::GetTreeOrigin(size_t iTree) const
{
	TAssert(iTree < m_avecOrigins.size());
	if (iTree >= m_avecOrigins.size())
		return DoubleVector();

	return m_avecOrigins[iTree];
}
コード例 #30
0
void CCharacterController::updateAction(btCollisionWorld* pCollisionWorld, btScalar deltaTime)
{
	if (!m_bColliding)
		return;

	TAssert(dynamic_cast<CCharacter*>(GetEntity()));

	static_cast<CCharacter*>(GetEntity())->CharacterMovement(pCollisionWorld, deltaTime);
}