void HudTrail::Render(Graphics::Renderer *r)
{
	PROFILE_SCOPED();
	//render trail
	if (m_trailPoints.size() > 1) {
		const vector3d vpos = m_transform * m_body->GetInterpPosition();
		m_transform[12] = vpos.x;
		m_transform[13] = vpos.y;
		m_transform[14] = vpos.z;
		m_transform[15] = 1.0;

		static std::vector<vector3f> tvts;
		static std::vector<Color> colors;
		tvts.clear();
		colors.clear();
		const vector3d curpos = m_body->GetInterpPosition();
		tvts.reserve(MAX_POINTS);
		colors.reserve(MAX_POINTS);
		tvts.push_back(vector3f(0.f));
		colors.push_back(Color::BLANK);
		float alpha = 1.f;
		const float decrement = 1.f / m_trailPoints.size();
		const Color tcolor = m_color;
		for (size_t i = m_trailPoints.size()-1; i > 0; i--) {
			tvts.push_back(-vector3f(curpos - m_trailPoints[i]));
			alpha -= decrement;
			colors.push_back(tcolor);
			colors.back().a = Uint8(alpha * 255);
		}

		r->SetTransform(m_transform);
		m_lines.SetData(tvts.size(), &tvts[0], &colors[0]);
		m_lines.Draw(r, m_renderState, Graphics::LINE_STRIP);
	}
}
void BallsView::Init(){
	camera.Init();
	camera.SwitchCamMode(true);
	camera.MoveA(vector3f(0,0,0));
	camera.RotateA(vector3f(0,M_PI/4,0));
	camera.ZoomR(-3);
}
Exemple #3
0
/* when ship is on rails it returns true and fills outPosOrient.
 * when ship has been released (or docked) it returns false.
 * Note station animations may continue for any number of stages after
 * ship has been released and is under player control again */
bool SpaceStationType::GetDockAnimPositionOrient(int port, int stage, double t, const vector3d &from, positionOrient_t &outPosOrient, const Ship *ship) const
{
	if ((stage < 0) && ((-stage) > numUndockStages)) return false;
	if ((stage > 0) && (stage > numDockingStages)) return false;

	lua_State *L = LmrGetLuaState();

	LUA_DEBUG_START(L);

	lua_pushcfunction(L, pi_lua_panic);
	// It's a function of form function(stage, t, from)
	model->PushAttributeToLuaStack("ship_dock_anim");
	if (!lua_isfunction(L, -1)) {
		Error("Spacestation model %s needs ship_dock_anim method", model->GetName());
	}
	lua_pushinteger(L, port+1);
	lua_pushinteger(L, stage);
	lua_pushnumber(L, double(t));
	vector3f *_from = MyLuaVec::pushVec(L);
	*_from = vector3f(from);
	// push model aabb as lua table: { min: vec3, max: vec3 }
	{
		Aabb aabb;
		ship->GetAabb(aabb);
		lua_createtable (L, 0, 2);
		vector3f *v = MyLuaVec::pushVec(L);
		*v = vector3f(aabb.max);
		lua_setfield(L, -2, "max");
		v = MyLuaVec::pushVec(L);
		*v = vector3f(aabb.min);
		lua_setfield(L, -2, "min");
	}

	lua_pcall(L, 5, 1, -7);
	bool gotOrient;
	if (lua_istable(L, -1)) {
		gotOrient = true;
		lua_pushinteger(L, 1);
		lua_gettable(L, -2);
		outPosOrient.pos = vector3d(*MyLuaVec::checkVec(L, -1));
		lua_pop(L, 1);

		lua_pushinteger(L, 2);
		lua_gettable(L, -2);
		outPosOrient.xaxis = vector3d(*MyLuaVec::checkVec(L, -1));
		lua_pop(L, 1);

		lua_pushinteger(L, 3);
		lua_gettable(L, -2);
		outPosOrient.yaxis = vector3d(*MyLuaVec::checkVec(L, -1));
		lua_pop(L, 1);
	} else {
		gotOrient = false;
	}
	lua_pop(L, 2);

	LUA_DEBUG_END(L, 0);

	return gotOrient;
}
Exemple #4
0
void Face::Draw()
{
	const Point &offset = GetActiveOffset();
	const Point &area = GetActiveArea();

	const float x = offset.x;
	const float y = offset.y;
	const float sx = area.x;
	const float sy = area.y;

	const vector2f texSize = m_texture->GetDescriptor().texSize;

	Graphics::VertexArray va(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0);
	va.Add(vector3f(x,    y,    0.0f), vector2f(0.0f,      0.0f));
	va.Add(vector3f(x,    y+sy, 0.0f), vector2f(0.0f,      texSize.y));
	va.Add(vector3f(x+sx, y,    0.0f), vector2f(texSize.x, 0.0f));
	va.Add(vector3f(x+sx, y+sy, 0.0f), vector2f(texSize.x, texSize.y));

	Graphics::Renderer *r = GetContext()->GetRenderer();
	s_material->texture0 = m_texture.get();
	auto state = GetContext()->GetSkin().GetAlphaBlendState();
	r->DrawTriangles(&va, state, s_material.Get(), Graphics::TRIANGLE_STRIP);

	Single::Draw();
}
void ObjectViewerView::Draw3D()
{
	m_renderer->ClearScreen();
	float znear, zfar;
	m_renderer->GetNearFarRange(znear, zfar);
	m_renderer->SetPerspectiveProjection(75.f, Pi::GetScrAspect(), znear, zfar);
	m_renderer->SetTransform(matrix4x4f::Identity());

	Graphics::Light light;
	light.SetType(Graphics::Light::LIGHT_DIRECTIONAL);

	if (Pi::MouseButtonState(SDL_BUTTON_RIGHT)) {
		int m[2];
		Pi::GetMouseMotion(m);
		m_camRot = matrix4x4d::RotateXMatrix(-0.002*m[1]) *
				matrix4x4d::RotateYMatrix(-0.002*m[0]) * m_camRot;
	}

	Body *body = Pi::player->GetNavTarget();
	if (body) {
		if (body->IsType(Object::STAR))
			light.SetPosition(vector3f(0.f));
		else {
			light.SetPosition(vector3f(0.577f));
		}
		m_renderer->SetLights(1, &light);

		body->Render(m_renderer, 0, vector3d(0,0,-viewingDist), m_camRot);
	}
}
Exemple #6
0
void Face::Draw()
{
	Graphics::Renderer *r = GetContext()->GetRenderer();
	if (!m_quad) {
		const Point &offset = GetActiveOffset();
		const Point &area = GetActiveArea();

		const float x = offset.x;
		const float y = offset.y;
		const float sx = area.x;
		const float sy = area.y;

		const vector2f texSize = m_texture->GetDescriptor().texSize;

		Graphics::VertexArray va(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0);
		va.Add(vector3f(x, y, 0.0f), vector2f(0.0f, 0.0f));
		va.Add(vector3f(x, y + sy, 0.0f), vector2f(0.0f, texSize.y));
		va.Add(vector3f(x + sx, y, 0.0f), vector2f(texSize.x, 0.0f));
		va.Add(vector3f(x + sx, y + sy, 0.0f), vector2f(texSize.x, texSize.y));

		Graphics::Renderer *r = GetContext()->GetRenderer();
		s_material->texture0 = m_texture.get();
		auto state = GetContext()->GetSkin().GetAlphaBlendState();
		m_quad.reset(new Graphics::Drawables::TexturedQuad(r, s_material, va, state));
	}
	m_quad->Draw(r);

	Single::Draw();
}
Exemple #7
0
	void DrawRoundEdgedRect(const float size[2], float rad, const Color &color, Graphics::RenderState *state)
	{
		static Graphics::VertexArray vts(Graphics::ATTRIB_POSITION);
		vts.Clear();

		const int STEPS = 6;
		if (rad > 0.5f*std::min(size[0], size[1])) rad = 0.5f*std::min(size[0], size[1]);
			// top left
			// bottom left
			for (int i=0; i<=STEPS; i++) {
				float ang = M_PI*0.5f*i/float(STEPS);
				vts.Add(vector3f(rad - rad*cos(ang), (size[1] - rad) + rad*sin(ang), 0.f));
			}
			// bottom right
			for (int i=0; i<=STEPS; i++) {
				float ang = M_PI*0.5 + M_PI*0.5f*i/float(STEPS);
				vts.Add(vector3f(size[0] - rad - rad*cos(ang), (size[1] - rad) + rad*sin(ang), 0.f));
			}
			// top right
			for (int i=0; i<=STEPS; i++) {
				float ang = M_PI + M_PI*0.5f*i/float(STEPS);
				vts.Add(vector3f((size[0] - rad) - rad*cos(ang), rad + rad*sin(ang), 0.f));
			}

			// top right
			for (int i=0; i<=STEPS; i++) {
				float ang = M_PI*1.5 + M_PI*0.5f*i/float(STEPS);
				vts.Add(vector3f(rad - rad*cos(ang), rad + rad*sin(ang), 0.f));
			}

		Screen::flatColorMaterial->diffuse = color;
		Screen::GetRenderer()->DrawTriangles(&vts, state, Screen::flatColorMaterial, Graphics::TRIANGLE_FAN);
	}
Exemple #8
0
void moon::display(const vector3 &moon_pos, const vector3 &sun_pos, double max_view_dist) const
{
	vector3 moon_dir = moon_pos.normal();
	double moon_size = max_view_dist/20;
	float moon_azimuth = atan2(-moon_dir.y, moon_dir.x);
	float moon_elevation = asin(moon_dir.z);

	glsl_moon->use();
	glsl_moon->set_gl_texture(*map_diffuse, loc_diffcol, 0);
	glsl_moon->set_gl_texture(*map_normal, loc_nrml, 1);
	//	transform light into object space
	matrix4 roth = matrix4::rot_z(-RAD_TO_DEG(moon_azimuth));
	matrix4 rotv = matrix4::rot_y(-RAD_TO_DEG(moon_elevation));
	matrix4 model_mat = roth*rotv;
	vector3 l = model_mat.inverse() * sun_pos;
	vector3 nl = vector3(-l.y, l.z, -l.x).normal();	//	OpenGL coordinates
	glsl_moon->set_uniform(loc_lightdir, nl);

	//	render moon
	glPushMatrix();
	model_mat.multiply_gl();
	glTranslated(0.95*max_view_dist, 0, 0);

	primitives::textured_quad(vector3f( 0,  moon_size,  moon_size),
				  vector3f( 0, -moon_size,  moon_size),
				  vector3f( 0, -moon_size, -moon_size),
				  vector3f( 0,  moon_size, -moon_size),
				  *map_diffuse).render_plain();
	glPopMatrix();
}
Exemple #9
0
void Billboard::Render(const matrix4x4f &trans, const RenderData *rd)
{
	Graphics::Renderer *r = GetRenderer();

	Graphics::VertexArray va(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0, 6);

	const matrix3x3f rot = trans.GetOrient().Transpose();

	//some hand-tweaked scaling, to make the lights seem larger from distance
	const float size = m_size * Graphics::GetFovFactor() * Clamp(trans.GetTranslate().Length() / 500.f, 0.25f, 15.f);

	const vector3f rotv1 = rot * vector3f(size/2.f, -size/2.f, 0.0f);
	const vector3f rotv2 = rot * vector3f(size/2.f, size/2.f, 0.0f);

	va.Add(m_offset-rotv1, vector2f(0.f, 0.f)); //top left
	va.Add(m_offset-rotv2, vector2f(0.f, 1.f)); //bottom left
	va.Add(m_offset+rotv2, vector2f(1.f, 0.f)); //top right

	va.Add(m_offset+rotv2, vector2f(1.f, 0.f)); //top right
	va.Add(m_offset-rotv2, vector2f(0.f, 1.f)); //bottom left
	va.Add(m_offset+rotv1, vector2f(1.f, 1.f)); //bottom right

	r->SetTransform(trans);
	r->DrawTriangles(&va, m_renderState, m_material.Get());
}
	//------------------------------------------------------------------------------------------------------
	RotatingRing::RotatingRing()
		:LocatableObject( this ),
		m_isMaked(false),
		m_pRingBuffer(NULL),
		m_fRadius(0)
	{
		float bs = 1.5 * 1;
		m_BindBox = aabbox3df( vector3f( -bs, -bs, -bs ), vector3f( bs, bs, bs ) );
		m_isMaked = true;
		m_fRadius = 1;
		ASSERT( 3 == RC_AXIS );
		VertexColor LineVertex[ RC_AXIS * RC_POINT ];
		static ushort Indies[RC_AXIS*RC_POINT*2];
		for ( int i = 0 ; i < RC_AXIS*RC_POINT*2; i += 2 )
		{
			Indies[i] = i/2;
			//Indies[i+1] = (i/2)%RC_POINT==0&&0!=i ? i-RC_POINT*2 : i/2+1 ;
			if ( i/2 == RC_POINT-1 || i/2 == RC_POINT*2-1 || i/2 == RC_POINT*3-1 )
			{
				Indies[i+1] = i/2-RC_POINT+1;
			}
			else
			{
				Indies[i+1] = i/2+1;
			}
		}
		m_pRingBuffer = NEW RendBuffer( Device::RM_LINES );
		m_pVertexBuffer = NEW VertexBuffer( Device::MU_DYNAMIC );
		m_pIndicesBuffer = NEW IndicesBuffer( Device::MU_STATIC );
		m_pRingBuffer->SetVertexBuffer( m_pVertexBuffer );
		m_pRingBuffer->SetIndicesBuffer( m_pIndicesBuffer );
		m_pIndicesBuffer->FlushIndiesBuffer( RC_AXIS*RC_POINT*2, Indies );
	}
	//------------------------------------------------------------------------------------------------------
	void RotatingRing::CreateRing( const float& r )
	{
		float bs = 1.5 * r;
		m_BindBox = aabbox3df( vector3f( -bs, -bs, -bs ), vector3f( bs, bs, bs ) );
		m_isMaked = true;
		m_fRadius = r;
		ASSERT( 3 == RC_AXIS );
		VertexColor LineVertex[ RC_AXIS * RC_POINT ];
		for ( int i = 0; i < RC_POINT; i ++ )
		{
			Matrix22f m;
			m.FromRadian( (PI / 180) * i );
			vector2f v( r, 0 );
			v *= m;
			LineVertex[i].SetVertex( vector4f( v.m_x, 0, v.m_y, 1 ) );//ΧÈÆyÖá
			LineVertex[i].SetColor( Color( 1, 0, 0, 1) );

			LineVertex[i+RC_POINT].SetVertex( vector4f( 0, v.m_x, v.m_y, 1 ) );//ΧÈÆxÖá
			LineVertex[i+RC_POINT].SetColor( Color( 0, 1, 0, 1) );

			LineVertex[i+2*RC_POINT].SetVertex( vector4f( v.m_x, v.m_y, 0, 1 ) );//ΧÈÆxÖá
			LineVertex[i+2*RC_POINT].SetColor( Color( 0, 0, 1, 1) );
		}
		m_pVertexBuffer->FlushVertexBuffer( RC_AXIS * RC_POINT, LineVertex );
	}
Exemple #12
0
void Camera::rotate() {
    n = to - at;
    n.normalize();
        
    // n_aux is in the plane defined by n and v
    vector3f n_aux(n.x, n.y-1, n.z);
    u = vector3f::crossProduct(n_aux,n);
    u.normalize();
    v = vector3f::crossProduct(u,n);
    v.normalize();
        
    //rotation in x
    matrix4x4f rx;
    rx.rotate(pitch, vector3f(1,0,0));
    rx.transformVector(&n);
    rx.transformVector(&v);
            
    //rotation in y
    matrix4x4f ry;
    ry.rotate(yaw, vector3f(0,1,0));
//    ry.rotate(yaw, v);
    ry.transformVector(&n);
    ry.transformVector(&u);

    //rotation in z
    matrix4x4f rz;
    rz.rotate(roll, vector3f(0,0,1));
    rz.transformVector(&v);
    rz.transformVector(&u);

}
Exemple #13
0
void Gradient::Draw()
{
	Graphics::Renderer *r = GetContext()->GetRenderer();
	if (!m_quad) {
		const Point &offset = GetActiveOffset();
		const Point &area = GetActiveArea();

		const float x = offset.x;
		const float y = offset.y;
		const float sx = area.x;
		const float sy = area.y;

		Graphics::VertexArray va(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_DIFFUSE);
		va.Add(vector3f(x, y, 0.0f), m_beginColor);
		va.Add(vector3f(x, y + sy, 0.0f), m_direction == HORIZONTAL ? m_beginColor : m_endColor);
		va.Add(vector3f(x + sx, y, 0.0f), m_direction == HORIZONTAL ? m_endColor : m_beginColor);
		va.Add(vector3f(x + sx, y + sy, 0.0f), m_endColor);

		auto renderState = GetContext()->GetSkin().GetAlphaBlendState();
		m_quad.reset(new Graphics::Drawables::TexturedQuad(r, m_material, va, renderState));
	}
	m_quad->Draw(r, Color(Color::WHITE.r, Color::WHITE.g, Color::WHITE.b, GetContext()->GetOpacity()*Color::WHITE.a));

	Container::Draw();
}
Exemple #14
0
	//--------------------------------------------------------------------------------------------------------------------------------------
	void EditCamera::Rotate( float xd, float yd )
	{
		Quaternionf q;
		q.RotateAxis( m_VerticalAixs,yd * m_RotateSpeed );
		Matrix44f mat = Math::Transformation<float>(NULL, NULL, NULL, &m_Target, &q, NULL);
		vector3f pos = Math::Transform_coord(this->GetPosition(), mat);

		q.RotateAxis( vector3f(0.0f, GetUp().Dot( vector3f(0, 1, 0)) < 0 ? -1.0f : 1.0f, 0.0f), xd * m_RotateSpeed );
		mat = Math::Transformation<float>(NULL, NULL, NULL, &m_Target, &q, NULL);
		pos =  Math::Transform_coord(pos, mat);
		m_VerticalAixs = Math::Transform_Quat(m_VerticalAixs, q);

		vector3f dir;
		if (m_isReverse)
		{
			dir = pos - m_Target;
		}
		else
		{
			dir = m_Target - pos;
		}
		dir.NormalizeSelf();
		vector3f up = dir.Cross(m_VerticalAixs);
		this->_LookAt(pos, pos + dir, up);	
	}
Exemple #15
0
SpeedLines::SpeedLines(Ship *s)
: m_ship(s)
, m_visible(false)
, m_dir(0.f)
{
	PROFILE_SCOPED();

	// init the static data
	SpeedLines::Init();

	m_points.reserve(DEPTH * DEPTH * DEPTH);
	for (int x = -DEPTH/2; x < DEPTH/2; x++) {
		for (int y = -DEPTH/2; y < DEPTH/2; y++) {
			for (int z = -DEPTH/2; z < DEPTH/2; z++) {
				m_points.push_back(vector3f(x * SPACING, y * SPACING, z * SPACING));
			}
		}
	}

	const Uint32 doubleNumPoints = static_cast<Uint32>(m_points.size()) * 2;
	m_varray.reset(new Graphics::VertexArray(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_DIFFUSE, doubleNumPoints));
	for( Uint32 i = 0; i < doubleNumPoints; i++ )
		m_varray->Add(vector3f(0.0f), Color::BLACK);

	Graphics::RenderStateDesc rsd;
	rsd.blendMode = Graphics::BLEND_ALPHA_ONE;
	rsd.depthWrite = false;
	m_renderState = Pi::renderer->CreateRenderState(rsd);

	CreateVertexBuffer( Pi::renderer, doubleNumPoints );
}
Exemple #16
0
Projectile::Projectile(): Body()
{
	m_orient = matrix4x4d::Identity();
	m_type = 1;
	m_age = 0;
	m_parent = 0;
	m_radius = 0;
	m_flags |= FLAG_DRAW_LAST;

	m_prog = new Render::Shader("flat", "#define TEXTURE0 1\n");

	m_sideTex = Pi::textureCache->GetBillboardTexture(PIONEER_DATA_DIR "/textures/projectile_l.png");
	m_glowTex = Pi::textureCache->GetBillboardTexture(PIONEER_DATA_DIR "/textures/projectile_w.png");

	//zero at projectile position
	//+x down
	//+y right
	//+z forwards (or projectile direction)
	const float w = 0.5f;

	vector3f one(0.f, -w, 0.f); //top left
	vector3f two(0.f,  w, 0.f); //top right
	vector3f three(0.f,  w, -1.f); //bottom right
	vector3f four(0.f, -w, -1.f); //bottom left

	//add four intersecting planes to create a volumetric effect
	for (int i=0; i < 4; i++) {
		m_verts.push_back(Vertex(one, 0.f, 1.f));
		m_verts.push_back(Vertex(two, 1.f, 1.f));
		m_verts.push_back(Vertex(three, 1.f, 0.f));

		m_verts.push_back(Vertex(three, 1.f, 0.f));
		m_verts.push_back(Vertex(four, 0.f, 0.f));
		m_verts.push_back(Vertex(one, 0.f, 1.f));

		one.ArbRotate(vector3f(0.f, 0.f, 1.f), DEG2RAD(45.f));
		two.ArbRotate(vector3f(0.f, 0.f, 1.f), DEG2RAD(45.f));
		three.ArbRotate(vector3f(0.f, 0.f, 1.f), DEG2RAD(45.f));
		four.ArbRotate(vector3f(0.f, 0.f, 1.f), DEG2RAD(45.f));
	}

	//create quads for viewing on end
	//these are added in the same vertex array to avoid a
	//vertex pointer change
	float gw = 0.5f;
	float gz = -0.1f;

	for (int i=0; i < 4; i++) {
		m_verts.push_back(Vertex(vector3f(-gw, -gw, gz), 0.f, 1.f));
		m_verts.push_back(Vertex(vector3f(-gw, gw, gz), 1.f, 1.f));
		m_verts.push_back(Vertex(vector3f(gw, gw, gz),1.f, 0.f));

		m_verts.push_back(Vertex(vector3f(gw, gw, gz), 1.f, 0.f));
		m_verts.push_back(Vertex(vector3f(gw, -gw, gz), 0.f, 0.f));
		m_verts.push_back(Vertex(vector3f(-gw, -gw, gz), 0.f, 1.f));

		gw -= 0.1f; // they get smaller
		gz -= 0.2; // as they move back
	}
}
Exemple #17
0
	void UpdateVBOs() {
		PROFILE_SCOPED()
		//create buffer and upload data
		Graphics::VertexBufferDesc vbd;
		vbd.attrib[0].semantic = Graphics::ATTRIB_POSITION;
		vbd.attrib[0].format   = Graphics::ATTRIB_FORMAT_FLOAT3;
		vbd.attrib[1].semantic = Graphics::ATTRIB_NORMAL;
		vbd.attrib[1].format   = Graphics::ATTRIB_FORMAT_FLOAT3;
		vbd.numVertices = ctx->NUMVERTICES();
		vbd.usage = Graphics::BUFFER_USAGE_STATIC;
		m_vertexBuffer.reset(Pi::renderer->CreateVertexBuffer(vbd));

		GasPatchContext::VBOVertex* vtxPtr = m_vertexBuffer->Map<GasPatchContext::VBOVertex>(Graphics::BUFFER_MAP_WRITE);
		assert(m_vertexBuffer->GetDesc().stride == sizeof(GasPatchContext::VBOVertex));
		
		const Sint32 edgeLen = ctx->edgeLen;
		const double frac = ctx->frac;
		for (Sint32 y=0; y<edgeLen; y++) {
			for (Sint32 x=0; x<edgeLen; x++) {
				const vector3d p = GetSpherePoint(x*frac, y*frac);
				const vector3d pSubCentroid = p - clipCentroid;
				clipRadius = std::max(clipRadius, p.Length());
				vtxPtr->pos = vector3f(pSubCentroid);
				vtxPtr->norm = vector3f(p);

				++vtxPtr; // next vertex
			}
		}
		m_vertexBuffer->Unmap();
	}
	//-------------------------------------------------------------------------------------
	void BillboardNode::SetBillBorad( const vector3f& pos, const vector2f& rectsize )
	{
		Billboard::SetBillBorad( pos, rectsize );
		m_pVertexBuffer->FlushVertexBuffer( COUNT_OF_VERTEX, m_VertexArray );
		m_BindBox.Reset();
		m_BindBox.Contains( vector3f(pos.m_x - rectsize.m_x, pos.m_y - rectsize.m_y, pos.m_z) );
		m_BindBox.Contains( vector3f(pos.m_x + rectsize.m_x, pos.m_y + rectsize.m_y, pos.m_z) );
	}
Exemple #19
0
Line3D::Line3D() : m_refreshVertexBuffer(true), m_width(2.0f), m_va( new Graphics::VertexArray(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_DIFFUSE, 2) )
{
	PROFILE_SCOPED()
	assert(m_va.get());
	// XXX bug in Radeon drivers will cause crash in glLineWidth if width >= 3
	m_va->Add(vector3f(0.f), Color(0));
	m_va->Add(vector3f(0.f), Color(255));
}
Exemple #20
0
void ScatterBiasArea(int roi, float scan_width, int steps, int samples, int qi_it, float angstep)
{
	std::vector<float> u=linspace(roi/2-scan_width/2,roi/2+scan_width/2, steps);
	
	QTrkComputedConfig cfg;
	cfg.width=cfg.height=roi;
	cfg.qi_angstep_factor = angstep;
	cfg.qi_iterations = qi_it;
	cfg.qi_angular_coverage = 0.7f;
	cfg.qi_roi_coverage = 1;
	cfg.qi_radial_coverage = 1.5f;
	cfg.qi_minradius=0;
	cfg.zlut_minradius=0;
	cfg.zlut_angular_coverage = 0.7f;
	cfg.zlut_roi_coverage = 1;
	cfg.zlut_radial_coverage = 1.5f;
	cfg.zlut_minradius = 0;
	cfg.qi_minradius = 0;
	cfg.com_bgcorrection = 0;
	cfg.xc1_profileLength = roi*0.8f;
	cfg.xc1_profileWidth = roi*0.2f;
	cfg.xc1_iterations = 1;
	cfg.Update();

	ImageData lut,orglut = ReadLUTFile("10x.radialzlut#4");
	vector3f ct(roi/2,roi/2,lut.h/2 + 0.123f);
	float dx = scan_width/steps;

	QueuedCPUTracker trk(cfg);
	ResampleLUT(&trk, &orglut, orglut.h, &lut);
	int maxval = 10000;

	ImageData tmp=ImageData::alloc(roi,roi);
	GenerateImageFromLUT(&tmp, &lut, 0, cfg.zlut_maxradius, vector3f(roi/2,roi/2,lut.h/2));
	ApplyPoissonNoise(tmp, maxval);

	std::string fn = SPrintf( "sb_area_roi%d_scan%d_steps%d_qit%d_N%d", roi, (int)scan_width, steps, qi_it, samples);
	WriteJPEGFile( (fn + ".jpg").c_str(), tmp);
	tmp.free();

	fn += ".txt";
	for (int y=0;y<steps;y++)  {
		for (int x=0;x<steps;x++)
		{
			vector3f cpos( (x+0.5f-steps/2) * dx, (y+0.5f-steps/2) * dx, 0 );

			cfg.qi_iterations = qi_it;
			auto r= AccBiasTest(orglut, &trk, samples, cpos+ct, vector3f(), 0, maxval, qi_it < 0 ? LT_XCor1D : 0);
			
			float row[] = { r.acc.x, r.acc.y, r.acc.z, r.bias.x, r.bias.y, r.bias.z,  r.crlb.x, r.crlb.z, samples };
			WriteArrayAsCSVRow(fn.c_str(), row, 9, x+y>0);

			dbgprintf("X=%d,Y=%d\n", x,y);
		}
	}
	orglut.free();
	lut.free();
}
Exemple #21
0
	//------------------------------------------------------------------------------------------------------
	void LineNode::SetLine( const vector4f& b, const vector4f& e )
	{
		m_BindBox.Reset();
		m_BindBox.Contains( vector3f(b) );
		m_BindBox.Contains( vector3f(e) );
		m_pVertexArray[0].SetVertex( b );
		m_pVertexArray[1].SetVertex( e );
		m_pVertexBuffer->FlushVertexBuffer( COUNT_OF_VERTEX, m_pVertexArray );
	}
Exemple #22
0
void Billboard::Render(const matrix4x4f &trans, const RenderData *rd)
{
	PROFILE_SCOPED()

	//some hand-tweaked scaling, to make the lights seem larger from distance (final size is in pixels)
	const float pixrad = Clamp(Graphics::GetScreenHeight() / trans.GetTranslate().Length(), 1.0f, 15.0f);
	const float size = (m_size * Graphics::GetFovFactor()) * pixrad;
	m_bbVA.Add(trans * vector3f(0.0f), vector3f(m_colorUVoffset, size));
}
Exemple #23
0
void Ship::Render(Graphics::Renderer *renderer, const Camera *camera, const vector3d &viewCoords, const matrix4x4d &viewTransform)
{
	if (IsDead()) return;

	m_shipFlavour.ApplyTo(GetModel());

	//angthrust negated, for some reason
	GetModel()->SetThrust(vector3f(m_thrusters), -vector3f(m_angThrusters));

	if (m_landingGearAnimation)
		m_landingGearAnimation->SetProgress(m_wheelState);

	//strncpy(params.pText[0], GetLabel().c_str(), sizeof(params.pText));
	RenderModel(renderer, viewCoords, viewTransform);

	// draw shield recharge bubble
	if (m_stats.shield_mass_left < m_stats.shield_mass) {
		const float shield = 0.01f*GetPercentShields();
		renderer->SetBlendMode(Graphics::BLEND_ADDITIVE);
		glPushMatrix();
		matrix4x4f trans = matrix4x4f::Identity();
		trans.Translate(viewCoords.x, viewCoords.y, viewCoords.z);
		trans.Scale(GetPhysRadius());
		renderer->SetTransform(trans);

		//fade based on strength
		Sfx::shieldEffect->GetMaterial()->diffuse =
			Color((1.0f-shield),shield,0.0,0.33f*(1.0f-shield));
		Sfx::shieldEffect->Draw(renderer);
		glPopMatrix();
		renderer->SetBlendMode(Graphics::BLEND_SOLID);
	}

	if (m_ecmRecharge > 0.0f) {
		// ECM effect: a cloud of particles for a sparkly effect
		vector3f v[100];
		for (int i=0; i<100; i++) {
			const double r1 = Pi::rng.Double()-0.5;
			const double r2 = Pi::rng.Double()-0.5;
			const double r3 = Pi::rng.Double()-0.5;
			v[i] = vector3f(viewTransform * (
				GetPosition() + GetPhysRadius() *
				vector3d(r1, r2, r3).Normalized()
			));
		}
		Color c(0.5,0.5,1.0,1.0);
		float totalRechargeTime = GetECMRechargeTime();
		if (totalRechargeTime >= 0.0f) {
			c.a = m_ecmRecharge / totalRechargeTime;
		}

		Sfx::ecmParticle->diffuse = c;
		renderer->SetBlendMode(Graphics::BLEND_ALPHA_ONE);
		renderer->DrawPointSprites(100, v, Sfx::ecmParticle, 50.f);
	}
}
Exemple #24
0
	void DrawRect(const vector2f &pos, const vector2f &size, const Color &c, Graphics::RenderState *state)
	{
		Graphics::VertexArray bgArr(Graphics::ATTRIB_POSITION, 4);
		bgArr.Add(vector3f(pos.x,size.y,0));
		bgArr.Add(vector3f(size.x,size.y,0));
		bgArr.Add(vector3f(size.x,pos.y,0));
		bgArr.Add(vector3f(pos.x,pos.y,0));
		Screen::flatColorMaterial->diffuse = c;
		Screen::GetRenderer()->DrawTriangles(&bgArr, state, Screen::flatColorMaterial, Graphics::TRIANGLE_FAN);
	}
Exemple #25
0
void Skin::DrawRectElement(const RectElement &element, const Point &pos, const Point &size, Graphics::BlendMode blendMode) const
{
	Graphics::VertexArray va(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0);

	va.Add(vector3f(pos.x,        pos.y,        0.0f), scaled(vector2f(element.pos.x,                element.pos.y)));
	va.Add(vector3f(pos.x,        pos.y+size.y, 0.0f), scaled(vector2f(element.pos.x,                element.pos.y+element.size.y)));
	va.Add(vector3f(pos.x+size.x, pos.y,        0.0f), scaled(vector2f(element.pos.x+element.size.x, element.pos.y)));
	va.Add(vector3f(pos.x+size.x, pos.y+size.y, 0.0f), scaled(vector2f(element.pos.x+element.size.x, element.pos.y+element.size.y)));

	m_renderer->DrawTriangles(&va, GetRenderState(blendMode), m_textureMaterial.Get(), Graphics::TRIANGLE_STRIP);
}
Exemple #26
0
void Skin::DrawRectColor(const Color &col, const Point &pos, const Point &size) const
{
	Graphics::VertexArray va(Graphics::ATTRIB_POSITION);

	va.Add(vector3f(pos.x,        pos.y,        0.0f));
	va.Add(vector3f(pos.x,        pos.y+size.y, 0.0f));
	va.Add(vector3f(pos.x+size.x, pos.y,        0.0f));
	va.Add(vector3f(pos.x+size.x, pos.y+size.y, 0.0f));

	m_colorMaterial->diffuse = col;
	m_renderer->DrawTriangles(&va, GetAlphaBlendState(), m_colorMaterial.Get(), Graphics::TRIANGLE_STRIP);
}
Exemple #27
0
// Looks at a given point
void Camera::lookat(vector3f target)
{
	target = target - pos;

	theta = getAngle(vector3f(-1, 0, 0), target);
	if( target.z > 0 )
		theta = -theta;

	phi = -getAngle(vector3f(0, 1, 0), target);

	setViewMatrix();
}
Exemple #28
0
	//--------------------------------------------------------------------------------------------------------------------------------------
	void FPSCamera::Rotate( float xd, float yd )
	{
		Quaternionf q;
		q.RotateAxis( m_VerticalAixs ,yd * m_RotateSpeed );
		vector3f dir = Math::Transform_Quat( this->GetForward() , q);

		q.RotateAxis( vector3f(0.0f, GetUp().Dot( vector3f(0, 1, 0)) < 0 ? -1.0f : 1.0f, 0.0f) , xd * m_RotateSpeed );
		m_VerticalAixs = Math::Transform_Quat(m_VerticalAixs, q);
		dir = Math::Transform_Quat( dir , q);
		vector3f up = dir.Cross( m_VerticalAixs );
		this->_LookAt(this->GetPosition(), this->GetPosition() + dir, up);
	}
Exemple #29
0
static void DrawAtmosphereSurface(Graphics::Renderer *renderer,
	const matrix4x4d &modelView, const vector3d &campos, float rad, Graphics::Material *mat)
{
	const int LAT_SEGS = 20;
	const int LONG_SEGS = 20;
	vector3d yaxis = campos.Normalized();
	vector3d zaxis = vector3d(1.0,0.0,0.0).Cross(yaxis).Normalized();
	vector3d xaxis = yaxis.Cross(zaxis);
	const matrix4x4d invrot = matrix4x4d::MakeRotMatrix(xaxis, yaxis, zaxis).InverseOf();

	renderer->SetTransform(modelView * matrix4x4d::ScaleMatrix(rad, rad, rad) * invrot);

	// what is this? Well, angle to the horizon is:
	// acos(planetRadius/viewerDistFromSphereCentre)
	// and angle from this tangent on to atmosphere is:
	// acos(planetRadius/atmosphereRadius) ie acos(1.0/1.01244blah)
	double endAng = acos(1.0/campos.Length())+acos(1.0/rad);
	double latDiff = endAng / double(LAT_SEGS);

	double rot = 0.0;
	float sinCosTable[LONG_SEGS+1][2];
	for (int i=0; i<=LONG_SEGS; i++, rot += 2.0*M_PI/double(LONG_SEGS)) {
		sinCosTable[i][0] = float(sin(rot));
		sinCosTable[i][1] = float(cos(rot));
	}

	/* Tri-fan above viewer */
	Graphics::VertexArray va(Graphics::ATTRIB_POSITION);
	va.Add(vector3f(0.f, 1.f, 0.f));
	for (int i=0; i<=LONG_SEGS; i++) {
		va.Add(vector3f(
			sin(latDiff)*sinCosTable[i][0],
			cos(latDiff),
			-sin(latDiff)*sinCosTable[i][1]));
	}
	renderer->DrawTriangles(&va, mat, Graphics::TRIANGLE_FAN);

	/* and wound latitudinal strips */
	double lat = latDiff;
	for (int j=1; j<LAT_SEGS; j++, lat += latDiff) {
		Graphics::VertexArray v(Graphics::ATTRIB_POSITION);
		float cosLat = cos(lat);
		float sinLat = sin(lat);
		float cosLat2 = cos(lat+latDiff);
		float sinLat2 = sin(lat+latDiff);
		for (int i=0; i<=LONG_SEGS; i++) {
			v.Add(vector3f(sinLat*sinCosTable[i][0], cosLat, -sinLat*sinCosTable[i][1]));
			v.Add(vector3f(sinLat2*sinCosTable[i][0], cosLat2, -sinLat2*sinCosTable[i][1]));
		}
		renderer->DrawTriangles(&v, mat, Graphics::TRIANGLE_STRIP);
	}
}
Exemple #30
0
void Projectile::Render(Graphics::Renderer *renderer, const Camera *camera, const vector3d &viewCoords, const matrix4x4d &viewTransform)
{
	vector3d _from = viewTransform * GetInterpPosition();
	vector3d _to = viewTransform * (GetInterpPosition() + m_dirVel);
	vector3d _dir = _to - _from;
	vector3f from(&_from.x);
	vector3f dir = vector3f(_dir).Normalized();

	vector3f v1, v2;
	matrix4x4f m = matrix4x4f::Identity();
	v1.x = dir.y; v1.y = dir.z; v1.z = dir.x;
	v2 = v1.Cross(dir).Normalized();
	v1 = v2.Cross(dir);
	m[0] = v1.x; m[4] = v2.x; m[8] = dir.x;
	m[1] = v1.y; m[5] = v2.y; m[9] = dir.y;
	m[2] = v1.z; m[6] = v2.z; m[10] = dir.z;

	m[12] = from.x;
	m[13] = from.y;
	m[14] = from.z;

	// increase visible size based on distance from camera, z is always negative
	// allows them to be smaller while maintaining visibility for game play
	const float dist_scale = float(viewCoords.z / -500);
	const float length = Equip::lasers[m_type].length + dist_scale;
	const float width = Equip::lasers[m_type].width + dist_scale;

	renderer->SetTransform(m * matrix4x4f::ScaleMatrix(width, width, length));

	Color color = Equip::lasers[m_type].color;
	// fade them out as they age so they don't suddenly disappear
	// this matches the damage fall-off calculation
	const float base_alpha = sqrt(1.0f - m_age/Equip::lasers[m_type].lifespan);
	// fade out side quads when viewing nearly edge on
	vector3f view_dir = vector3f(viewCoords).Normalized();
	color.a = (base_alpha * (1.f - powf(fabs(dir.Dot(view_dir)), length))) * 255;

	if (color.a > 3) {
		s_sideMat->diffuse = color;
		renderer->DrawTriangles(s_sideVerts.get(), s_renderState, s_sideMat.get());
	}

	// fade out glow quads when viewing nearly edge on
	// these and the side quads fade at different rates
	// so that they aren't both at the same alpha as that looks strange
	color.a = (base_alpha * powf(fabs(dir.Dot(view_dir)), width)) * 255;

	if (color.a > 3) {
		s_glowMat->diffuse = color;
		renderer->DrawTriangles(s_glowVerts.get(), s_renderState, s_glowMat.get());
	}
}