//-----------------------------------------------------------------------------------
void Renderer::DrawVertexArray(const Vertex_PCT* vertexes, int numVertexes, DrawMode drawMode /*= DrawMode::QUADS*/)
{
	if (numVertexes == 0)
	{
		return;
	}
	MeshBuilder builder;
	builder.Begin();
	for (int i = 0; i < numVertexes; ++i)
	{
		builder.SetColor(vertexes[i].color);
		builder.SetUV(vertexes[i].texCoords);
		builder.SetTBN(Vector3::ZERO, Vector3::ZERO, Vector3::ZERO);
		builder.AddVertex(vertexes[i].pos);
		builder.AddIndex(i);
	}
	builder.End();

	Mesh* mesh = new Mesh();
	builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
	mesh->m_drawMode = drawMode;
	MeshRenderer* thingToRender = new MeshRenderer(mesh, m_defaultMaterial);
	m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
	GL_CHECK_ERROR();
	thingToRender->Render();
	delete mesh;
}
//-----------------------------------------------------------------------------------
void Path::Render() const
{
    MeshBuilder builder;
    builder.Begin();
    const float TILE_SIZE = 25.0f;
    for (PathNode* node : m_openList)
    {
        Vector2 bottomLeft = Vector2(node->position) * TILE_SIZE;
        builder.AddTexturedAABB(AABB2(bottomLeft, bottomLeft + (Vector2::ONE * TILE_SIZE)), Vector2::ZERO, Vector2::ONE, RGBA(0x0000FF7F));
        Renderer::instance->DrawText2D(bottomLeft, std::to_string(node->f).substr(0, 4), 0.5f, RGBA::WHITE, false, BitmapFont::CreateOrGetFontFromGlyphSheet("Runescape"));
    }
    for (PathNode* node : m_closedList)
    {
        Vector2 bottomLeft = Vector2(node->position) * TILE_SIZE;
        builder.AddTexturedAABB(AABB2(bottomLeft, bottomLeft + (Vector2::ONE * TILE_SIZE)), Vector2::ZERO, Vector2::ONE, RGBA(0xFF00007F));
        Renderer::instance->DrawText2D(bottomLeft, std::to_string(node->f).substr(0, 4), 0.5f, RGBA::WHITE, false, BitmapFont::CreateOrGetFontFromGlyphSheet("Runescape"));
    }
    for (PathNode* node : m_resultantPath)
    {
        Vector2 bottomLeft = Vector2(node->position) * TILE_SIZE;
        builder.AddTexturedAABB(AABB2(bottomLeft, bottomLeft + (Vector2::ONE * TILE_SIZE)), Vector2::ZERO, Vector2::ONE, RGBA(0x00FF007F));
    }

    Vector2 bottomLeft = (Vector2(m_currentGoal) * TILE_SIZE);
    builder.AddTexturedAABB(AABB2(bottomLeft, bottomLeft + (Vector2::ONE * TILE_SIZE)), Vector2::ZERO, Vector2::ONE, RGBA(0x00FF007F));
    
    builder.End();
    Mesh* mesh = new Mesh();
    builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
    MeshRenderer* renderer = new MeshRenderer(mesh, Renderer::instance->m_defaultMaterial);
    renderer->Render();
    delete mesh;
}
//-----------------------------------------------------------------------------------
void Renderer::DrawText2D(const Vector2& position, const std::string& asciiText, float scale, const RGBA& tint /*= RGBA::WHITE*/, bool drawShadow /*= false*/, const BitmapFont* font /*= nullptr*/, const Vector2& right /*= Vector3::UNIT_X*/, const Vector2& up /*= Vector3::UNIT_Z*/)
{
	//To be used when I expand this method to 3D text
	UNUSED(up);
	UNUSED(right);
	if (asciiText.empty())
	{
		return;
	}
	if (font == nullptr)
	{
		font = m_defaultFont;
	}
	int stringLength = asciiText.size();
	Vector2 cursorPosition = position + (Vector2::UNIT_Y * (float)font->m_maxHeight * scale);
	const Glyph* previousGlyph = nullptr;
	MeshBuilder builder;
	builder.Begin();
	for (int i = 0; i < stringLength; i++)
	{
		unsigned char currentCharacter = asciiText[i];
		const Glyph* glyph = font->GetGlyph(currentCharacter);
		float glyphWidth = static_cast<float>(glyph->width) * scale;
		float glyphHeight = static_cast<float>(glyph->height) * scale;

		if (previousGlyph)
		{
			const Vector2 kerning = font->GetKerning(*previousGlyph, *glyph);
			cursorPosition += (kerning * scale);
		}
		Vector2 offset = Vector2(glyph->xOffset * scale, -glyph->yOffset * scale);
		Vector2 topRight = cursorPosition + offset + Vector2(glyphWidth, 0.0f);
		Vector2 bottomLeft = cursorPosition + offset - Vector2(0.0f, glyphHeight);
		AABB2 quadBounds = AABB2(bottomLeft, topRight);
		AABB2 glyphBounds = font->GetTexCoordsForGlyph(*glyph);
		if (drawShadow)
		{
			float shadowWidthOffset = glyphWidth / 10.0f;
			float shadowHeightOffset = glyphHeight / -10.0f;
			Vector2 shadowOffset = Vector2(shadowWidthOffset, shadowHeightOffset);
			AABB2 shadowBounds = AABB2(bottomLeft + shadowOffset, topRight + shadowOffset);
			builder.AddTexturedAABB(shadowBounds, glyphBounds.mins, glyphBounds.maxs, RGBA::BLACK);
		}
		builder.AddTexturedAABB(quadBounds, glyphBounds.mins, glyphBounds.maxs, tint);
		cursorPosition.x += glyph->xAdvance * scale;
		previousGlyph = glyph;
	}
	builder.End();

	Mesh* mesh = new Mesh();
	builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
	mesh->m_drawMode = DrawMode::TRIANGLES;
	MeshRenderer* thingToRender = new MeshRenderer(mesh, font->GetMaterial());
	m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
	GL_CHECK_ERROR();
	thingToRender->Render();
	delete mesh;
	delete thingToRender;
}
//-----------------------------------------------------------------------------------
void Renderer::DrawText2D
	( const Vector2& startBottomLeft
	, const std::string& asciiText
	, float cellWidth
	, float cellHeight
	, const RGBA& tint /*= RGBA::WHITE*/
	, bool drawShadow /*= false*/
	, const BitmapFont* font /*= nullptr*/)
{
	const float SHADOW_WIDTH_OFFSET = cellWidth / 10.0f;
	const float SHADOW_HEIGHT_OFFSET = cellHeight / -10.0f;
	const Vector2 SHADOW_OFFSET = Vector2(SHADOW_WIDTH_OFFSET, SHADOW_HEIGHT_OFFSET);

	if (asciiText.empty())
	{
		return;
	}
	MeshBuilder builder;
	builder.Begin();
	if (font == nullptr)
	{
		font = m_defaultFont;
	}
	int stringLength = asciiText.size();
	Vector2 currentPosition = startBottomLeft;
	for (int i = 0; i < stringLength; i++)
	{
		unsigned char currentCharacter = asciiText[i];
		Vector2 topRight = currentPosition + Vector2(cellWidth, cellHeight);
		AABB2 quadBounds = AABB2(currentPosition, topRight);
		AABB2 glyphBounds =	font->GetTexCoordsForGlyph(currentCharacter);
		if (drawShadow)
		{
			AABB2 shadowBounds = AABB2(currentPosition + SHADOW_OFFSET, topRight + SHADOW_OFFSET);
			builder.AddTexturedAABB(shadowBounds, glyphBounds.mins, glyphBounds.maxs, RGBA::BLACK);
		}
		builder.AddTexturedAABB(quadBounds, glyphBounds.mins, glyphBounds.maxs, tint);
		currentPosition.x += cellWidth;
	}
	builder.End();

	Mesh* mesh = new Mesh();
	builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO);
	mesh->m_drawMode = DrawMode::TRIANGLES;
	MeshRenderer* thingToRender = new MeshRenderer(mesh, font->GetMaterial());
	m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
	GL_CHECK_ERROR();
	thingToRender->Render();
	delete mesh;
	delete thingToRender;
}
Beispiel #5
0
//-----------------------------------------------------------------------------------
void Renderer::DrawVertexArray(const Vertex_PCT* vertexes, int numVertexes, DrawMode drawMode /*= QUADS*/, Texture* texture /*= nullptr*/)
{
// 	if (!texture)
// 	{
// 		texture = m_defaultTexture;
// 	}
// 	BindTexture(*texture);
// 	glEnableClientState(GL_VERTEX_ARRAY);
// 	glEnableClientState(GL_COLOR_ARRAY);
// 	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// 	
// 	glVertexPointer(3, GL_FLOAT, sizeof(Vertex_PCT), &vertexes[0].pos);
// 	glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_PCT), &vertexes[0].color);
// 	glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex_PCT), &vertexes[0].texCoords);
// 
// 	glDrawArrays(GetDrawMode(drawMode), 0, numVertexes);
// 
// 	glDisableClientState(GL_VERTEX_ARRAY);
// 	glDisableClientState(GL_COLOR_ARRAY);
// 	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// 	UnbindTexture();
	if (numVertexes == 0)
	{
		return;
	}
	MeshBuilder builder;
	builder.Begin();
	for (int i = 0; i < numVertexes; ++i)
	{
		builder.SetColor(vertexes[i].color);
		builder.SetUV(vertexes[i].texCoords);
		builder.SetTBN(Vector3::ZERO, Vector3::ZERO, Vector3::ZERO);
		builder.AddVertex(vertexes[i].pos);
		builder.AddIndex(i);
	}
	builder.End();

	Mesh* mesh = new Mesh();
	builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy);
	mesh->m_drawMode = drawMode;
	MeshRenderer thingToRender = MeshRenderer(mesh, m_defaultMaterial);
	m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
	GL_CHECK_ERROR();
	thingToRender.Render();
	delete mesh;
}
Beispiel #6
0
//-----------------------------------------------------------------------------------
void Renderer::DrawVertexArrayModern(const Vertex_PCT* vertexes, int numVertexes, Renderer::DrawMode drawMode /*= QUADS*/, Texture* texture /*= nullptr*/)
{
	MeshBuilder builder;
	builder.Begin();
	for (int i = 0; i < numVertexes; ++i)
	{
		builder.SetColor(vertexes[i].color);
		builder.SetUV(vertexes[i].texCoords);
		builder.SetTBN(Vector3::ZERO, Vector3::ZERO, Vector3::ZERO);
		builder.AddVertex(vertexes[i].pos);
		builder.AddIndex(i);
	}
	builder.End();

	Mesh* mesh = new Mesh();
	builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy);
	mesh->m_drawMode = drawMode;
	MeshRenderer thingToRender = MeshRenderer(mesh, m_defaultMaterial);
	m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop());
	GL_CHECK_ERROR();
	thingToRender.Render();
	delete mesh;
}