#include "renderer.h"
#include "renderer_opengl.h"
#include "renderer_d3d9.h"

Viewport::Viewport(float left,float top,float right,float bottom):
	left(left), top(top), right(right), bottom(bottom) {}
Viewport::Viewport(RenderTarget *target)
{
	left=0; top=0;
	right=target->GetWidth();
	bottom=target->GetHeight();
}

Renderer::Renderer(Core *core):
	proj_stack_ptr(0), mdvw_stack_ptr(0),
	cullmode(RAVEN_CULL_BACK), stateflags(0),
	blend(RAVEN_BLEND_NONE), blendmask(0.5f)
{
	this->core=core;

	active_lights=new Light *[RAVEN_MAXIMUM_LIGHTS];
	memset(active_lights,0,sizeof(Light *)*RAVEN_MAXIMUM_LIGHTS);

	proj_stack[0]=identity4();
	mdvw_stack[0]=identity4();

	main_fb=new RenderTarget((float)core->GetWidth(),(float)core->GetHeight());
	curr_target=main_fb;

	viewport.left=viewport.top=0;
	viewport.right=(float)core->GetWidth();
	viewport.bottom=(float)core->GetHeight();
}

Renderer::~Renderer()
{
	delete[] active_lights;
}

void Renderer::TargetViewport(const Viewport &vp)
{
	viewport=vp;
}

Viewport Renderer::TargetViewport()
{
	return viewport;
}

void Renderer::PushProjection()
{
	proj_stack[++proj_stack_ptr]=proj_stack[proj_stack_ptr-1];
}

void Renderer::LoadProjection(const Matrix4x4 &mat)
{
	proj_stack[proj_stack_ptr]=mat;
}

void Renderer::LoadProjection(const Projection &proj)
{
	Matrix4x4 mat;
	Projection _proj(proj);
	_proj.ToMatrix(mat);
	proj_stack[proj_stack_ptr]=mat;
}

void Renderer::MultProjection(Matrix4x4 &mat)
{
	proj_stack[proj_stack_ptr]=proj_stack[proj_stack_ptr]*mat;
}

void Renderer::PopProjection()
{
	proj_stack_ptr--;
}

Matrix4x4 Renderer::GetProjection()
{
	return proj_stack[proj_stack_ptr];
}

Frustum Renderer::GetProjectionFrustum()
{
	Frustum frustum;
	frustum.LoadFrustum(proj_stack[proj_stack_ptr]);
	return frustum;
}

unsigned int Renderer::GetProjectionStackDepth()
{
	return proj_stack_ptr;
}

void Renderer::PushModelView()
{
	mdvw_stack[++mdvw_stack_ptr]=mdvw_stack[mdvw_stack_ptr-1];
}

void Renderer::LoadModelView(const Matrix4x4 &mat)
{
	mdvw_stack[mdvw_stack_ptr]=mat;
}

void Renderer::MultModelView(const Matrix4x4 &mat)
{
	mdvw_stack[mdvw_stack_ptr]=mdvw_stack[mdvw_stack_ptr]*mat;
}

void Renderer::PopModelView()
{
	mdvw_stack_ptr--;
}

Matrix4x4 Renderer::GetModelView()
{
	return mdvw_stack[mdvw_stack_ptr];
}

unsigned int Renderer::GetModelViewStackDepth()
{
	return mdvw_stack_ptr;
}

void Renderer::SetCullMode(CullMode mode)
{
	cullmode=mode;
}

CullMode Renderer::GetCullMode()
{
	return cullmode;
}

void Renderer::State(int state,bool on)
{
	if (on)
		stateflags|=state;
	else
		stateflags&=~state;
}

bool Renderer::State(int state)
{
	return (stateflags&state)!=0;
}

void Renderer::Blend(BlendMode mode,float mask)
{
	blend=mode;
	blendmask=mask;
}

BlendMode Renderer::Blend()
{
	return blend;
}

void Renderer::BlendMask(float mask)
{
	blendmask=mask;
}

float Renderer::BlendMask()
{
	return blendmask;
}

void Renderer::Material(const RenderMaterial &material)
{
	this->material=material;
}

RenderMaterial Renderer::Material()
{
	return material;
}

bool Renderer::EnableLight(int slot,Light *light)
{
	if (RAVEN_MAXIMUM_LIGHTS<slot) return false;
	if (active_lights[slot]!=NULL) return false;
	active_lights[slot]=light;
	return true;
}

bool Renderer::DisableLight(int slot)
{
	if (active_lights[slot]==NULL) return false;
	active_lights[slot]=NULL;
	return true;
}

VertexBuffer *Renderer::CreateVertexBuffer(int attribs)
{
	return new VertexBuffer(attribs);
}

Renderer *__create_renderer(Core *core)
{
	switch (core->GetType())
	{
	case RAVEN_OPENGL:
		return new RendererOpenGL(core);
		break;
	case RAVEN_DIRECT3D9:
#if defined(WIN32)||defined(__WIN32__)||defined(_MSC_VER)
		return new RendererD3D9(core);
#else
        return NULL;
#endif
		break;
	default:
		return NULL;
		break;
	}
}