// push Renderable nodes
//virtual
bool ControlPointGob::GetRenderables(RenderableNodeCollector* collector, RenderContext* context)
{
Mesh* mesh = ShapeLibGetMesh(RenderShape::QuadLineStrip);
m_localBounds = mesh->bounds;
const float pointSize = 8; // control point size in pixels
float upp = context->Cam().ComputeUnitPerPixel(float3(&m_world.M41),
context->ViewPort().y);
float scale = pointSize * upp;
Matrix scaleM = Matrix::CreateScale(scale);
float3 objectPos = float3(m_world.M41,m_world.M42,m_world.M43);
Matrix b = Matrix::CreateBillboard(objectPos,context->Cam().CamPos(),context->Cam().CamUp(),context->Cam().CamLook());
Matrix billboard = scaleM * b;
// calculate bounds for screen facing quad
float3 transformed, min, max;
transformed = mesh->pos[0];
transformed.Transform(billboard);
min = max = transformed;
for (auto it = mesh->pos.begin(); it != mesh->pos.end(); ++it)
{
transformed = (*it);
transformed.Transform(billboard);
min = minimize(min, transformed);
max = maximize(max, transformed);
}
m_bounds = AABB(min,max);
// give it same color as curve
int color = 0xFFFF0000;
CurveGob* curve = (CurveGob*)m_parent;
if(curve != NULL)
{
color = curve->GetColor();
}
// set renderable
RenderableNode r;
r.mesh = mesh;
ConvertColor(color, &r.diffuse);
r.objectId = GetInstanceId();
r.bounds = m_bounds;
r.WorldXform = billboard;
r.SetFlag(RenderableNode::kTestAgainstBBoxOnly, true);
r.SetFlag(RenderableNode::kShadowCaster, false);
r.SetFlag(RenderableNode::kShadowReceiver, false);
collector->Add(r, RenderFlags::None, Shaders::BasicShader);
return true;
}
void SkyDome::Render( RenderContext* context)
{
if(IsVisible() == false)
return;
RenderableNode r;
r.mesh = ShapeLibGetMesh(RenderShape::Sphere);
r.objectId = GetInstanceId();
r.textures[TextureType::Cubemap] = m_texture ? m_texture : TextureLib::Inst()->GetDefault(TextureType::Cubemap);
r.SetFlag( RenderableNode::kShadowCaster, false );
r.SetFlag( RenderableNode::kShadowReceiver, false );
SkyDomeShader* pShader =(SkyDomeShader*) ShaderLib::Inst()->GetShader(Shaders::SkyDomeShader);
pShader->Begin( context);
pShader->SetRenderFlag( RenderFlags::None ); // call this *after* Begin()
pShader->Draw(r);
pShader->End();
}
void Locator::BuildRenderables()
{
m_renderables.clear();
Model* model = NULL;
assert(m_resource);
model = (Model*)m_resource->GetTarget();
assert(model && model->IsReady());
const NodeDict& nodes = model->Nodes();
for(auto nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
{
Node* node = nodeIt->second;
assert(m_modelTransforms.size() >= node->index);
const Matrix& world = m_modelTransforms[node->index]; // transform array holds world matricies already, not local
for(auto geoIt = node->geometries.begin(); geoIt != node->geometries.end(); ++geoIt)
{
Geometry* geo = (*geoIt);
Material * mat = geo->material;
RenderableNode renderNode;
renderNode.mesh = geo->mesh;
renderNode.WorldXform = world;
renderNode.bounds = geo->mesh->bounds;
renderNode.bounds.Transform(renderNode.WorldXform);
renderNode.objectId = GetInstanceId();
renderNode.diffuse = mat->diffuse;
renderNode.specular = mat->specular.xyz();
renderNode.specPower = mat->power;
renderNode.SetFlag( RenderableNode::kShadowCaster, GetCastsShadows() );
renderNode.SetFlag( RenderableNode::kShadowReceiver, GetReceivesShadows() );
LightingState::Inst()->UpdateLightEnvironment(renderNode);
for(unsigned int i = TextureType::MIN; i < TextureType::MAX; ++i)
{
renderNode.textures[i] = geo->material->textures[i];
}
m_renderables.push_back(renderNode);
}
}
}
//-----------------------------------------------------------------------------------------------------------------------------------
// push Renderable nodes
//virtual
void CurveGob::GetRenderables(RenderableNodeCollector* collector, RenderContext* context)
{
if (!IsVisible(context->Cam().GetFrustum()) || m_points.size() < 2)
return;
super::GetRenderables(collector, context);
RenderableNode r;
r.mesh = &m_mesh;
ConvertColor(m_color, &r.diffuse);
r.objectId = GetInstanceId();
r.SetFlag( RenderableNode::kShadowCaster, false );
r.SetFlag( RenderableNode::kShadowReceiver, false );
r.bounds = m_bounds;
r.WorldXform = m_world;
collector->Add( r, RenderFlags::None, Shaders::BasicShader );
// draw control points.
for( auto it = m_points.begin(); it != m_points.end(); ++it)
{
(*it)->GetRenderables(collector,context);
}
}
