void PrimitiveShapeRenderer::RenderWireframeBox( const Vector3& vEdgeLengths, const Matrix34& world_pose, const SFloatRGBAColor& wireframe_color )
{
if( !sg_NoLightingShader.IsLoaded() )
sg_NoLightingShader = GetNoLightingShader();
// Wireframes are always rendered without lighting
ShaderManager *pShaderMgr = sg_NoLightingShader.GetShaderManager();
// ShaderManager *pShaderMgr = GetShaderManagerForPrimitiveShape();
if( !pShaderMgr )
return;
ShaderManager& shader_mgr = *pShaderMgr;
Result::Name res = shader_mgr.SetTexture( 0, GetSingleColorWhiteTexture() );
res = shader_mgr.SetTexture( 1, GetSingleColorWhiteTexture() );
Vector3 r( vEdgeLengths * 0.5f );
shader_mgr.SetWorldTransform( ToMatrix44(world_pose) * Matrix44Scaling(r.x,r.y,r.z) );
// Vector3 radii = vEdgeLengths * 0.5f;
Vector3 vertices[8] =
{
Vector3( 1, 1, 1),// * radii,
Vector3( 1, 1,-1),// * radii,
Vector3(-1, 1,-1),// * radii,
Vector3(-1, 1, 1),// * radii,
Vector3( 1,-1, 1),// * radii,
Vector3( 1,-1,-1),// * radii,
Vector3(-1,-1,-1),// * radii,
Vector3(-1,-1, 1),// * radii,
};
/*
uint indices[24] =
{
0, 1, 1, 2, 2, 3, 3, 0,
0, 1, 1, 2, 2, 3, 3, 0,
0, 1, 1, 2, 2, 3, 3, 0
};
GetPrimitiveRenderer().DrawIndexedLines( vertices, 8, indices, 24, wireframe_color );
*/
Vector3 *v = vertices;
const Vector3 points[24] =
{
v[0], v[1], v[1], v[2], v[2], v[3], v[3], v[0],
v[0], v[4], v[1], v[5], v[2], v[6], v[3], v[7],
v[4], v[5], v[5], v[6], v[6], v[7], v[7], v[4],
};
shader_mgr.Begin();
const int num_edges = 12;
for( int i=0; i<num_edges; i++ )
{
GetPrimitiveRenderer().DrawLine( points[i*2], points[i*2+1], wireframe_color, wireframe_color );
}
}
ShaderManager *PrimitiveShapeRenderer::GetShaderManagerForPrimitiveShape()
{
ShaderManager *pShaderMgr = m_Shader.GetShaderManager();
if( pShaderMgr )
return pShaderMgr;
if( !sg_NoLightingShader.IsLoaded() )
sg_NoLightingShader = GetNoLightingShader();
return sg_NoLightingShader.GetShaderManager();
}
void ShadowMapDemo::RenderShadowReceivers( Camera& camera, ShaderHandle *shaders, ShaderTechniqueHandle *shader_techniques )
{
// ShaderManager *pShaderMgr = m_pShadowMapManager->GetShader().GetShaderManager();
ShaderHandle shader = shaders[VertexBlendType::NONE];
ShaderManager *pShaderMgr = shader.GetShaderManager();
if( !pShaderMgr )
return;
ShaderManager& shader_mgr = *pShaderMgr;
ShaderTechniqueHandle tech = m_pShadowMapManager->ShaderTechniqueForShadowReceiver();
Result::Name res = shader_mgr.SetTechnique( tech );
RenderScene( shader_mgr );
}
void C2DPrimitiveRenderer_GL::Render( General2DVertex *paVertex, int num_vertices, PrimitiveType::Name primitive_type )
{
ShaderHandle shader
= sg_2DPrimitiveCommonShaders.GetShader( C2DPrimitiveCommonShaders::ST_DIFFUSE_COLOR );
ShaderManager *pShaderMgr = shader.GetShaderManager();
if( !pShaderMgr )
{
LOG_PRINT_ERROR( "The shader for 2D primitives is not available." );
return;
}
pShaderMgr->Begin();
RenderViaVertexAttribArray( paVertex, num_vertices, NULL, 0, ToGLPrimitiveType(primitive_type) );
}
void C2DPrimitiveRenderer_GL::Render( const General2DVertex *pVertices, uint num_vertices, U16 *indices, uint num_indices, PrimitiveType::Name primitive_type, TextureHandle texture )
{
ShaderHandle shader
= sg_2DPrimitiveCommonShaders.GetShader( C2DPrimitiveCommonShaders::ST_DIFFUSE_COLOR_AND_TEXTURE );
ShaderManager *pShaderMgr = shader.GetShaderManager();
if( !pShaderMgr )
{
return;
}
pShaderMgr->SetTexture( 0, texture );
pShaderMgr->Begin();
RenderViaVertexAttribArray( pVertices, num_vertices, indices, num_indices, ToGLPrimitiveType(primitive_type) );
}
ShaderHandle LoadShader(const char *vertexShaderFilename, const char *fragmentShaderFilename, const char *shaderResourceName) // if not provided, there is no default shader resource name
{
if(!vertexShaderFilename || !fragmentShaderFilename) { return ShaderHandle((Shader*)0); };
// Compile and check vertex shader
VertexShaderHandle vsh = ResourceManager::get().CreateAndGetResource<VertexShaderObject>(vertexShaderFilename); // ASSUME WE WANT TO RELOAD SHADER (COULD CHECK IF ID ALREADY VALID)
if(!vsh->Valid())
{
if(!vsh->CompileFromFile(vertexShaderFilename))
{
vsh->PrintShaderLog(std::cout);
ResourceManager::get().RemoveResource(vsh->GetResourceID());
return ShaderHandle((Shader*)0);
}
}
// Compile and check fragment shader
FragmentShaderHandle fsh = ResourceManager::get().CreateAndGetResource<FragmentShaderObject>(fragmentShaderFilename); // ASSUME WE WANT TO RELOAD SHADER (COULD CHECK IF ID ALREADY VALID)
if(!fsh->Valid())
{
if(!fsh->CompileFromFile(fragmentShaderFilename))
{
fsh->PrintShaderLog(std::cout);
ResourceManager::get().RemoveResource(vsh->GetResourceID());
ResourceManager::get().RemoveResource(fsh->GetResourceID());
return ShaderHandle((Shader*)0);
}
}
// Compile and check program object
ShaderHandle sh = shaderResourceName ? ResourceManager::get().CreateAndGetResource<Shader>(shaderResourceName) : ResourceManager::get().CreateAndGetResource<Shader>();
if(sh->GetVS() && sh->GetFS()) // SAME SHADER
{
if(sh->GetVS()->GetResourceID() == vsh->GetResourceID() && sh->GetFS()->GetResourceID() == fsh->GetResourceID())
{
return sh;
}
};
if(!sh->CreateProgram(vsh, fsh))
{
sh->PrintProgramLog(std::cout);
ResourceManager::get().RemoveResource(vsh->GetResourceID());
ResourceManager::get().RemoveResource(fsh->GetResourceID());
ResourceManager::get().RemoveResource(sh->GetResourceID());
return ShaderHandle((Shader*)0);
}
return sh;
};
void MiscShaderDemo::RenderMeshes()
{
GraphicsDevice().Enable( RenderStateType::LIGHTING );
GraphicsDevice().Enable( RenderStateType::DEPTH_TEST );
GraphicsDevice().Enable( RenderStateType::FACE_CULLING );
GraphicsDevice().SetCullingMode( CullingMode::COUNTERCLOCKWISE );
GraphicsDevice().Enable( RenderStateType::ALPHA_BLEND );
ShaderHandle shader = GetCurrentShader();
ShaderManager *pShaderMgr = shader.GetShaderManager();
if( !pShaderMgr )
return;
ShaderManager& shader_mgr = *pShaderMgr;
// render the scene
shader_mgr.SetViewerPosition( GetCurrentCamera().GetPosition() );
// SetLights( pShaderMgr ? true : false );
shader_mgr.SetWorldTransform( Matrix44Identity() );
// GetShaderManagerHub().PushViewAndProjectionMatrices( GetCurrentCamera() );
if( 2 < m_Meshes.size() )
{
boost::shared_ptr<BasicMesh> pMesh = m_Meshes[2].GetMesh();
if( pMesh )
pMesh->Render( shader_mgr );
}
// GetShaderManagerHub().PopViewAndProjectionMatrices_NoRestore();
}
namespace amorphous
{
using namespace std;
static ShaderHandle sg_NoLightingShader;
static TextureHandle sg_SingleColorWhiteTexture;
static TextureHandle GetSingleColorWhiteTexture()
{
if( !sg_SingleColorWhiteTexture.IsLoaded() )
{
sg_SingleColorWhiteTexture = CreateSingleColorTexture( SFloatRGBAColor::White(), 1, 1 );
}
return sg_SingleColorWhiteTexture;
}
/// Used when a rectangle in 3D space is rendered via custom mesh
/// This function do not set vertex positions of the rect mesh,
/// since they are calculated when Draw3DRect() is called.
static void InitRectMesh( CustomMesh& mesh, const SFloatRGBAColor& vertex_diffuse_color )
{
U32 vertex_format_flags
= VFF::POSITION
| VFF::NORMAL
| VFF::DIFFUSE_COLOR
| VFF::TEXCOORD2_0;
mesh.InitVertexBuffer( 4, vertex_format_flags );
mesh.SetNormals( Vector3(0,0,1) );
mesh.SetDiffuseColors( vertex_diffuse_color );
vector<unsigned int> indices;
indices.resize( 6 );
indices[0] = 0;
indices[1] = 2;
indices[2] = 1;
indices[3] = 0;
indices[4] = 3;
indices[5] = 2;
mesh.SetIndices( indices );
vector<CMMA_TriangleSet> triangle_sets;
triangle_sets.resize( 1 );
triangle_sets[0].m_iStartIndex = 0;
triangle_sets[0].m_iMinIndex = 0;
triangle_sets[0].m_iNumVertexBlocksToCover = 4;
triangle_sets[0].m_iNumTriangles = 2;
triangle_sets[0].m_AABB = AABB3( Vector3(0,0,0), Vector3(0,0,0) );
mesh.SetTriangleSets( triangle_sets );
}
CustomMesh PrimitiveShapeRenderer::ms_BoxMesh;
CustomMesh PrimitiveShapeRenderer::ms_RectMesh;
PrimitiveShapeRenderer::PrimitiveShapeRenderer()
{
// ShaderResourceDesc desc;
// desc = non_programmable;
// m_Shader.Load( desc );
}
void PrimitiveShapeRenderer::RenderSphere( const Sphere& sphere, const SFloatRGBAColor& color )
{
}
void PrimitiveShapeRenderer::RenderBox( const Vector3& vEdgeLengths, const Matrix34& world_pose, const SFloatRGBAColor& color )
{
ShaderManager *pShaderMgr = GetShaderManagerForPrimitiveShape();
if( !pShaderMgr )
return;
ShaderManager& shader_mgr = *pShaderMgr;
Vector3 s( vEdgeLengths );
shader_mgr.SetWorldTransform( ToMatrix44(world_pose) * Matrix44Scaling(s.x,s.y,s.z) );
if( ms_BoxMesh.GetNumVertices() == 0 )
{
BoxMeshGenerator generator;
generator.Generate( Vector3(1,1,1), MeshGenerator::DEFAULT_VERTEX_FLAGS, color );
C3DMeshModelArchive mesh_archive( generator.GetMeshArchive() );
bool loaded = ms_BoxMesh.LoadFromArchive( mesh_archive );
}
else
ms_BoxMesh.SetDiffuseColors( color );
ms_BoxMesh.Render( shader_mgr );
}
void PrimitiveShapeRenderer::RenderCapsule( float radius, float height, const Matrix34& world_pose, const SFloatRGBAColor& color )
{
}
void PrimitiveShapeRenderer::RenderCylinder( float radius, float height, const Matrix34& world_pose, const SFloatRGBAColor& color )
{
}
ShaderManager *PrimitiveShapeRenderer::GetShaderManagerForPrimitiveShape()
{
ShaderManager *pShaderMgr = m_Shader.GetShaderManager();
if( pShaderMgr )
return pShaderMgr;
if( !sg_NoLightingShader.IsLoaded() )
sg_NoLightingShader = GetNoLightingShader();
return sg_NoLightingShader.GetShaderManager();
}
Result::Name PrimitiveShapeRenderer::RenderPlane(
const Vector3 *positions,
const Vector3& normal,
const SFloatRGBAColor& color,
TextureHandle& texture,
const TEXCOORD2& top_left,
const TEXCOORD2& bottom_right,
ShaderManager& shader_mgr
)
{
if( ms_RectMesh.GetNumVertices() == 0 )
InitRectMesh( ms_RectMesh, color );
else
ms_RectMesh.SetDiffuseColors( color );
// Set the four vertices of the rectangle.
const unsigned int num_vertices_to_set = 4;
ms_RectMesh.SetPositions( positions, num_vertices_to_set );
ms_RectMesh.UpdateAABBs();
ms_RectMesh.SetNormals( normal );
TEXCOORD2 tex_coords[4] =
{
TEXCOORD2( top_left.u, top_left.v ),
TEXCOORD2( bottom_right.u, top_left.v ),
TEXCOORD2( bottom_right.u, bottom_right.v ),
TEXCOORD2( top_left.u, bottom_right.v )
};
ms_RectMesh.Set2DTexCoords( tex_coords, num_vertices_to_set, 0 );
// if( ms_RectMesh.GetNumMaterials() == 0 )
// return Result::UNKNOWN_ERROR;
// Temporarily override the texture
ms_RectMesh.Materials().resize( 1 );
ms_RectMesh.Material(0).Texture.resize( 1 );
ms_RectMesh.Material(0).Texture[0] = texture;
ms_RectMesh.Render( shader_mgr );
ms_RectMesh.Material(0).Texture[0] = TextureHandle();
return Result::SUCCESS;
}
void PrimitiveShapeRenderer::RenderPlane(
const Matrix34& pose,
float width,
float height,
const SFloatRGBAColor& color,
TextureHandle& texture,
const TEXCOORD2& top_left,
const TEXCOORD2& bottom_right
)
{
ShaderManager *pShaderMgr = GetShaderManagerForPrimitiveShape();
if( !pShaderMgr )
return;
ShaderManager& shader_mgr = *pShaderMgr;
shader_mgr.SetWorldTransform( pose );
float hr = width * 0.5f; // horizontal raidus
float vr = height * 0.5f; // vertical raidus
const Vector3 positions[4] =
{
Vector3(-hr, vr,0),
Vector3( hr, vr,0),
Vector3( hr,-vr,0),
Vector3(-hr,-vr,0)
};
const Vector3 normal = pose.matOrient.GetColumn(1);
RenderPlane( positions, normal, color, texture, top_left, bottom_right, shader_mgr );
}
void PrimitiveShapeRenderer::RenderAxisAlignedPlane(
uint axis,
const Vector3& vCenter,
float span_0,
float span_1,
const SFloatRGBAColor& color,
TextureHandle& texture,
const TEXCOORD2& top_left,
const TEXCOORD2& bottom_right
)
{
if( 6 <= axis )
return;
uint uaxis = axis % 3;
uint span_index_0 = (uaxis+1) % 3;
uint span_index_1 = (uaxis+2) % 3;
if( 3 <= axis )
std::swap( span_index_0, span_index_1 );
Vector3 normal( Vector3(0,0,0) );
normal[uaxis] = (axis < 3) ? 1.0f : -1.0f;
Vector3 corners[4] =
{
vCenter,
vCenter,
vCenter,
vCenter
};
corners[0][span_index_0] -= span_0 * 0.5f;
corners[0][span_index_1] += span_1 * 0.5f;
corners[1][span_index_0] += span_0 * 0.5f;
corners[1][span_index_1] += span_1 * 0.5f;
corners[2][span_index_0] += span_0 * 0.5f;
corners[2][span_index_1] -= span_1 * 0.5f;
corners[3][span_index_0] -= span_0 * 0.5f;
corners[3][span_index_1] -= span_1 * 0.5f;
TextureHandle default_texture;
TextureHandle texture_to_set;
if( texture.IsLoaded() )
texture_to_set = texture;
else
{
if( !default_texture.IsLoaded() )
default_texture = CreateSingleColorTexture( SFloatRGBAColor::White(), 1, 1 );
texture_to_set = default_texture;
}
ShaderManager *pShaderMgr = GetShaderManagerForPrimitiveShape();
if( !pShaderMgr )
return;
ShaderManager& shader_mgr = *pShaderMgr;
shader_mgr.SetWorldTransform( Matrix44Identity() );
Result::Name res = shader_mgr.SetTexture( 0, texture_to_set );
// Commented out; lighting does not work in the OpenGL mode
// when the texture is set to the second stage.
// res = shader_mgr.SetTexture( 1, texture_to_set );
RenderPlane( corners, normal, color, texture_to_set, top_left, bottom_right, shader_mgr );
}
void PrimitiveShapeRenderer::RenderFloorPlane( const Vector3& vCenter, float width, float depth, const SFloatRGBAColor& color, TextureHandle& texture, const TEXCOORD2& top_left, const TEXCOORD2& bottom_right )
{
RenderAxisAlignedPlane( 1, vCenter, width, depth, color, texture, top_left, bottom_right );
}
void PrimitiveShapeRenderer::RenderWireframeBox( const Vector3& vEdgeLengths, const Matrix34& world_pose, const SFloatRGBAColor& wireframe_color )
{
if( !sg_NoLightingShader.IsLoaded() )
sg_NoLightingShader = GetNoLightingShader();
// Wireframes are always rendered without lighting
ShaderManager *pShaderMgr = sg_NoLightingShader.GetShaderManager();
// ShaderManager *pShaderMgr = GetShaderManagerForPrimitiveShape();
if( !pShaderMgr )
return;
ShaderManager& shader_mgr = *pShaderMgr;
Result::Name res = shader_mgr.SetTexture( 0, GetSingleColorWhiteTexture() );
res = shader_mgr.SetTexture( 1, GetSingleColorWhiteTexture() );
Vector3 r( vEdgeLengths * 0.5f );
shader_mgr.SetWorldTransform( ToMatrix44(world_pose) * Matrix44Scaling(r.x,r.y,r.z) );
// Vector3 radii = vEdgeLengths * 0.5f;
Vector3 vertices[8] =
{
Vector3( 1, 1, 1),// * radii,
Vector3( 1, 1,-1),// * radii,
Vector3(-1, 1,-1),// * radii,
Vector3(-1, 1, 1),// * radii,
Vector3( 1,-1, 1),// * radii,
Vector3( 1,-1,-1),// * radii,
Vector3(-1,-1,-1),// * radii,
Vector3(-1,-1, 1),// * radii,
};
/*
uint indices[24] =
{
0, 1, 1, 2, 2, 3, 3, 0,
0, 1, 1, 2, 2, 3, 3, 0,
0, 1, 1, 2, 2, 3, 3, 0
};
GetPrimitiveRenderer().DrawIndexedLines( vertices, 8, indices, 24, wireframe_color );
*/
Vector3 *v = vertices;
const Vector3 points[24] =
{
v[0], v[1], v[1], v[2], v[2], v[3], v[3], v[0],
v[0], v[4], v[1], v[5], v[2], v[6], v[3], v[7],
v[4], v[5], v[5], v[6], v[6], v[7], v[7], v[4],
};
shader_mgr.Begin();
const int num_edges = 12;
for( int i=0; i<num_edges; i++ )
{
GetPrimitiveRenderer().DrawLine( points[i*2], points[i*2+1], wireframe_color, wireframe_color );
}
}
} // namespace amorphous
bool World::LoadShaders()
{
multiTexturingSampleShader = LoadShader("Data/Shaders/multitex.vert", "Data/Shaders/multitex.frag"); // multitexturing test shader
particleSystemBaseShader = LoadShader("Data/Shaders/particlesystembase.vert", "Data/Shaders/particlesystembase.frag"); // particle system base shader
texturedParticleShader = LoadShader("Data/Shaders/texturedParticle.vert", "Data/Shaders/texturedParticle.frag"); // texture particle shader
if(texturedParticleShader)
{
texturedParticleShader->SetUniform("AlphaMap",0);
texturedParticleShader->SetUniform("ColorMap",1);
}
phongShader = LoadShader("Data/Shaders/phong.vert", "Data/Shaders/phong.frag"); // phong test shader
if(phongShader)
{
phongShader->SetUniform("lightPosition", float3(0,10,0));
phongShader->SetUniform("fAmbient", Color::GREY);
phongShader->SetUniform("fDiffuse", Color::WHITE);
phongShader->SetUniform("baseMap", houseTexture);
phongShader->SetUniform("applyTexture", true);
}
// Globe shader
globeShader = LoadShader("Data/Shaders/globe.vert", "Data/Shaders/globe.frag"); // globe shader
// Lighting shaders
directionalLightShader = LoadShader("Data/Shaders/directionalLight.vert", "Data/Shaders/directionalLight.frag");
spotlightShader = LoadShader("Data/Shaders/spotlight.vert", "Data/Shaders/spotlight.frag");
ambientLightShader = LoadShader("Data/Shaders/ambientLight.vert", "Data/Shaders/ambientLight.frag");
// Normal mapping shaders
normalMap_AmbientShader = LoadShader("Data/Shaders/NormalMapping/normalMapping_ambient_light.vert", "Data/Shaders/NormalMapping/normalMapping_ambient_light.frag");
normalMap_DirectionalShader = LoadShader("Data/Shaders/NormalMapping/normalMapping_directional_light.vert", "Data/Shaders/NormalMapping/normalMapping_directional_light.frag");
normalMap_SpotlightsShader = LoadShader("Data/Shaders/NormalMapping/normalMapping_spotlights.vert", "Data/Shaders/NormalMapping/normalMapping_spotlights.frag");
normalMap_DirectionalShader->SetUniform("baseMap",0);
normalMap_DirectionalShader->SetUniform("normalMap",1);
normalMap_SpotlightsShader->SetUniform("baseMap",0);
normalMap_SpotlightsShader->SetUniform("normalMap",1);
// Displacement mapping terrain shaders
terrainShaders.Terrain_Displacement_Ambient_Shader = LoadShader("Data/Shaders/TerrainShaders/displacement_ambient.vert", "Data/Shaders/TerrainShaders/displacement_ambient.frag");
terrainShaders.Terrain_Displacement_Directional_Shader = LoadShader("Data/Shaders/TerrainShaders/displacement_directional.vert", "Data/Shaders/TerrainShaders/displacement_directional.frag");
terrainShaders.Terrain_Displacement_Spotlights_Shader = LoadShader("Data/Shaders/TerrainShaders/displacement_spotlights.vert", "Data/Shaders/TerrainShaders/displacement_spotlights.frag");
ShaderHandle displacementAmbientShader = terrainShaders.Terrain_Displacement_Ambient_Shader,
displacementDirectionalShader = terrainShaders.Terrain_Displacement_Directional_Shader,
displacementSpotlightsShader = terrainShaders.Terrain_Displacement_Spotlights_Shader;
displacementAmbientShader->SetUniform("colorMap", 0); displacementAmbientShader->SetUniform("snowMap", 1);
displacementAmbientShader->SetUniform("normalMap", 2); displacementAmbientShader->SetUniform("displacementMap", 3);
displacementDirectionalShader->SetUniform("colorMap", 0); displacementDirectionalShader->SetUniform("snowMap", 1);
displacementDirectionalShader->SetUniform("normalMap", 2); displacementDirectionalShader->SetUniform("displacementMap", 3);
displacementSpotlightsShader->SetUniform("colorMap", 0); displacementSpotlightsShader->SetUniform("snowMap", 1);
displacementSpotlightsShader->SetUniform("normalMap", 2); displacementSpotlightsShader->SetUniform("displacementMap", 3);
displacementSpotlightsShader->SetUniform("vposmult", 0);
// Load all the tree shaders
treeShaders.Tree_Ambient_Shader = LoadShader("Data/Shaders/TreeShaders/ambientLight.vert", "Data/Shaders/TreeShaders/ambientLight.frag");
treeShaders.FlatNonTextured_Directional_Shader = LoadShader("Data/Shaders/TreeShaders/FlatShading/directionalLight.vert", "Data/Shaders/TreeShaders/FlatShading/directionalLight.frag");
treeShaders.SmoothShaded_Spot_Shader = LoadShader("Data/Shaders/TreeShaders/FlatShading/spotlight.vert", "Data/Shaders/TreeShaders/FlatShading/spotlight.frag");
treeShaders.SmoothShaded_Directional_Shader = LoadShader("Data/Shaders/TreeShaders/SmoothShading/directionalLight.vert", "Data/Shaders/TreeShaders/SmoothShading/directionalLight.frag");
treeShaders.SmoothShaded_Spot_Shader = LoadShader("Data/Shaders/TreeShaders/SmoothShading/spotlight.vert", "Data/Shaders/TreeShaders/SmoothShading/spotlight.frag");
return true;
};
// Initializes CCopyEntity::m_pMeshRenderMethod
// - Initialize the mesh render method
// - Initialize shader parameter loaders
// - Create alpha entities
// - Creates a shader
void BaseEntity::InitEntityGraphics( CCopyEntity &entity,
ShaderHandle& shader,
ShaderTechniqueHandle& tech )
{
if( shader.IsLoaded()
&& tech.GetTechniqueName()
&& 0 < strlen(tech.GetTechniqueName()) )
{
CreateMeshRenderMethod( EntityHandle<>( entity.Self() ), shader, tech );
}
else
{
InitMeshRenderMethod( entity );
}
// create transparent parts of the model as separate entities
if( m_EntityFlag & BETYPE_SUPPORT_TRANSPARENT_PARTS )
{
// Remove any previous alpha entities
int next_child_index = 0;
while( next_child_index < entity.GetNumChildren() )
// for( int i=0; i<entity.GetNumChildren(); i++ )
{
shared_ptr<CCopyEntity> pChild = entity.m_aChild[next_child_index].Get();
if( IsValidEntity(pChild.get())
&& pChild->GetEntityTypeID() == CCopyEntityTypeID::ALPHA_ENTITY )
{
CCopyEntity *pChildRawPtr = pChild.get();
m_pStage->TerminateEntity( pChildRawPtr );
}
else
next_child_index += 1;
}
CreateAlphaEntities( &entity );
}
shared_ptr<BasicMesh> pMesh = entity.m_MeshHandle.GetMesh();
if( !pMesh )
return;
BasicMesh& mesh = *pMesh;
const int num_mesh_materials = mesh.GetNumMaterials();
std::vector<GenericShaderDesc> shader_descs;
shader_descs.resize( num_mesh_materials );
std::vector<int> mirror_subsets_indices;
// std::vector<int> non_mirror_subsets_indices;
if( m_MeshProperty.m_MeshDesc.IsValid() )
// if( true )
{
// The mesh is specified in the base entity
}
else
{
// base entity has no mesh
// - entity's mesh is individual
shader_descs.resize( num_mesh_materials );
for( int i=0; i<num_mesh_materials; i++ )
{
// Fill out the shader desc based on the parameter values of the material
// reflection
bool registered_as_mirror = RegisterAsMirrorIfReflective( entity, mesh, i, shader_descs[i] );
if( registered_as_mirror )
mirror_subsets_indices.push_back( i );
// specularity
if( 0.001f < mesh.GetMaterial(i).m_Mat.fSpecularity )
shader_descs[i].Specular = SpecularSource::UNIFORM;
else
shader_descs[i].Specular = SpecularSource::NONE;
}
vector< pair< GenericShaderDesc, vector<unsigned int> > > grouped_descs;
group_elements( shader_descs, grouped_descs );
// Do a NULL check just in case
// The mesh render method is initialized by InitMeshRenderMethod() above.
if( !entity.m_pMeshRenderMethod )
entity.m_pMeshRenderMethod.reset( new MeshContainerRenderMethod );
bool shader_loaded = false;
if( grouped_descs.size() == 1 )
{
SubsetRenderMethod& render_method = entity.m_pMeshRenderMethod->PrimaryMeshRenderMethod();
render_method.m_Technique.SetTechniqueName( "Default" );
render_method.m_ShaderDesc.pShaderGenerator.reset( new GenericShaderGenerator( grouped_descs[0].first ) );
// shader_loaded = render_method.Load();
shader_loaded = render_method.m_Shader.Load( render_method.m_ShaderDesc );
}
else
{
LOG_PRINT_WARNING( "Mesh materials need different shaders. This situation is not supported yet (the total number of materials: " + to_string(num_mesh_materials) + ")." );
}
}
}
void BaseEntity::RenderAsShadowReceiver(CCopyEntity* pCopyEnt)
{
ONCE( LOG_PRINT_ERROR( " Not implemented yet." ) );
PROFILE_FUNCTION();
// set option to disable texture settings
ShadowMapManager *pShadowMgr = m_pStage->GetEntitySet()->GetRenderManager()->GetShadowManager();
if( !pShadowMgr )
return;
shared_ptr<BasicMesh> pMesh = pCopyEnt->m_MeshHandle.GetMesh();
if( !pMesh )
return;
ShaderHandle shader = pShadowMgr->GetShader();
ShaderManager *pShaderMgr = shader.GetShaderManager();
if( !pShaderMgr )
return;
pShaderMgr->SetWorldTransform( pCopyEnt->GetWorldPose() );
ShaderTechniqueHandle tech;
const U32 entity_flags = pCopyEnt->GetEntityFlags();
if( entity_flags & BETYPE_SHADOW_RECEIVER )
tech = pShadowMgr->ShaderTechniqueForShadowReceiver( VertexBlendType::NONE );
else // i.e. entity_flags & BETYPE_SHADOW_CASTER. See EntityNode::RenderShadowReceivers() for details.
tech = pShadowMgr->ShaderTechniqueForNonShadowedCasters( VertexBlendType::NONE );
pShaderMgr->SetTechnique( tech );
pMesh->Render( *pShaderMgr );
/* shared_ptr<MeshContainerRenderMethod> pMeshRenderMethod;
const bool is_skeletal_mesh = (pMesh->GetMeshType() == MeshType::SKELETAL);
if( is_skeletal_mesh )
{
pMeshRenderMethod = this->m_MeshProperty.m_pSkeletalShadowReceiverRenderMethod;
shared_ptr<SkeletalMesh> pSkeletalMesh
= dynamic_pointer_cast<SkeletalMesh,BasicMesh>(pMesh);
// if( !this->m_MeshProperty.m_pBlendTransformsLoader )
// InitShadowCasterReceiverSettings( pSkeletalMesh, this->m_MeshProperty );
this->m_MeshProperty.m_pBlendTransformsLoader->SetSkeletalMesh( pSkeletalMesh );
// pSkeletalMesh->SetLocalTransformToCache( 0, Matrix34Identity() );
// pSkeletalMesh->SetLocalTransformsFromCache();
}
else
pMeshRenderMethod = this->m_MeshProperty.m_pShadowReceiverRenderMethod;
if( true )//render_all_subsets )
{
// pMeshRenderMethod->MeshRenderMethod().resize( 1 );
SubsetRenderMethod& mesh_render_method = pMeshRenderMethod->MeshRenderMethod()[0];
mesh_render_method.m_Shader = pShadowMgr->GetShader();
// const char *tech = is_skeletal_mesh ? "SceneShadowMap_VertexBlend" : "SceneShadowMap";
// mesh_render_method.m_Technique.SetTechniqueName( tech );
VertexBlendType::Name blend_type = is_skeletal_mesh ? VertexBlendType::QUATERNION_AND_VECTOR3 : VertexBlendType::NONE;
mesh_render_method.m_Technique = pShadowMgr->ShaderTechniqueForShadowReceiver( blend_type );
// render_method.SetMeshRenderMethod( mesh_render_method, 0 );
pMeshRenderMethod->RenderMesh( pCopyEnt->m_MeshHandle, pCopyEnt->GetWorldPose() );
}
else
{
// how to render the mesh if each subset is rendered by different render methods
}
*/
}