/*
=====================
ActionLayer::LoadResources
=====================
*/
void ActionLayer::LoadResources()
{
ListenFrame();
/* Load MoveToActions */
for (int x = -1; x <= 1; x += 2)
{
for (int y = -1; y <= 1; y += 2)
{
Pim::Sprite *sprite = new Pim::Sprite("lighttiles.png");
sprite->position = Pim::Vec2(400.f + 100.f*x, 300.f + 100.f*y);
AddChild(sprite);
Pim::MoveToAction *action = new Pim::MoveToAction(Pim::Vec2(400.f, 300.f), 1.f);
sprite->RunAction(action);
}
}
/* Load MoveBy actions */
for (int i = 0; i < 2; i++)
{
Pim::Sprite *sprite = new Pim::Sprite("lighttiles.png");
sprite->position = Pim::Vec2( 50.f, 50.f + 500.f * i);
AddChild(sprite);
int fac = (!i) ? (1) : (-1);
Pim::MoveByAction *action = new Pim::MoveByAction(Pim::Vec2(700.f, 500.f*fac), 2.f);
sprite->RunAction(action);
}
/* Load RotateBy actions */
for (int i = 0; i < 2; i++)
{
Pim::Sprite *sprite = new Pim::Sprite("lighttiles.png");
sprite->position = Pim::Vec2(400.f, 50.f + 500.f * i);
AddChild(sprite);
Pim::RotateByAction *action = new Pim::RotateByAction(-720.f, 2.f);
sprite->RunAction(action);
}
/* Load TintActions */
for (int x = -1; x <= 1; x += 2)
{
for (int y = -1; y <= 1; y += 2)
{
Pim::Sprite *sprite = new Pim::Sprite("lighttiles.png");
sprite->position = Pim::Vec2(400.f + 100.f*x, 300.f + 100.f*y);
AddChild(sprite);
Pim::Color color(
0.5f + 0.25f*x,
0.5f - 0.25f*y,
1.f,
1.f
);
Pim::TintAction *action = new Pim::TintAction(color, 2.f);
sprite->RunAction(action);
}
}
/* Load ActionQueue */
for (int i = -1; i <= 1; i += 2)
{
Pim::DelayAction *delay = new Pim::DelayAction(0.5f);
Pim::MoveByAction *a0 = new Pim::MoveByAction(Pim::Vec2(10.f*i, 10.f), 0.25f);
Pim::MoveByAction *a1 = new Pim::MoveByAction(Pim::Vec2(10.f, 10.f*i), 0.25f);
Pim::TintAction *a2 = new Pim::TintAction(Pim::Color(1.f, 1.f, 1.f, 0.f), 0.25f);
Pim::TintAction *a3 = new Pim::TintAction(Pim::Color(1.f, 1.f, 1.f, 1.f), 0.25f);
Pim::MoveToAction *a4 = new Pim::MoveToAction(Pim::Vec2(50.f, 300.f+250.f*i), 0.5f);
Pim::TintAction *a5 = new Pim::TintAction(Pim::Color(0.f, 0.f, 0.f, 1.f), 0.5f);
Pim::TintAction *a6 = new Pim::TintAction(Pim::Color(1.f, 1.f, 1.f, 1.f), 0.5f);
Pim::ActionQueueRepeat *aqr = new Pim::ActionQueueRepeat(1,2,a5,a6);
aqr->infinite = true;
Pim::ActionQueue *aq = new Pim::ActionQueue(7, delay, a0, a1, a2, a3, a4, aqr);
Pim::Sprite *sprite = new Pim::Sprite("lighttiles.png");
sprite->position = Pim::Vec2(400.f + 200.f*i, 100.f);
AddChild(sprite);
sprite->RunActionQueue(aq);
}
/* Load ActionQueueRepeat */
for (int i = -1; i <= 1; i += 2)
{
Pim::TintAction *a0 = new Pim::TintAction(Pim::Color(1.f, 0.f, 0.f, 1.f), 0.25f);
Pim::RotateByAction *a1 = new Pim::RotateByAction(180.f, 0.5f);
Pim::ScaleByAction *a2 = new Pim::ScaleByAction(Pim::Vec2(1.f, 1.f), 0.25f);
Pim::ScaleByAction *a3 = new Pim::ScaleByAction(Pim::Vec2(-1.f, -1.f), 0.25f);
Pim::MoveToAction *a4 = new Pim::MoveToAction(Pim::Vec2(400.f, 300.f), 0.25f);
Pim::MoveByAction *a5 = new Pim::MoveByAction(Pim::Vec2(-300.f*i, 0.f), 0.25f);
Pim::TintAction *a6 = new Pim::TintAction(Pim::Color(1.f, 1.f, 1.f, 1.f), 0.25f);
Pim::ActionQueueRepeat *aq = new Pim::ActionQueueRepeat(2, 7, a0,a1,a2,a3,a4,a5,a6);
aq->infinite = true;
Pim::Sprite *sprite = new Pim::Sprite("lighttiles.png");
sprite->position = Pim::Vec2(400.f + 300.f*i, 300.f);
AddChild(sprite);
sprite->RunActionQueue(aq);
}
/* Load the shader */
shader = Pim::ShaderManager::AddShader(
"uniform sampler2D tex;\n"
"uniform float time;\n"
"void main(void)\n"
"{\n"
" vec2 c = gl_TexCoord[0].xy;\n"
" float m = (sin(c.x*100.0)+1.0)/100.0;\n"
" c.x += m;\n"
" gl_FragColor = texture2D(tex, c);\n"
"}\n",
"void main(void){\n"
" gl_Position=ftransform();\n"
" gl_TexCoord[0] = gl_MultiTexCoord0;\n"
"}\n",
"actionShader");
if (shader) {
shader->SetUniform1i("tex", 0);
SetShader(shader);
} else {
printf("Failed to compile ActionShader!!\n");
}
}
void Graphic::DrawTexture(TEXTURE_ID id, const Matrix4* mat_){
SetShader(SHADER_ID::TEXTURE_SHADER);
Matrix4 mat = *mat_;
//texture[id].Draw(&RConvert(&mat),&shader[sID]);
animBind = false;
}
bool CRenderSystem::prepareMaterial(/*const */CMaterial& material, float fOpacity) // 由于使用了自动注册纹理的机制,很遗憾的导致不能用“const”
{
CTextureMgr& TM = GetTextureMgr();
for (size_t i=0;i<8;++i)
{
if (material.uTexture[i]==-1)
{
material.uTexture[i] = TM.RegisterTexture(material.getTexture(i));
}
// ----
SetTexture(i, material.uTexture[i]);
// ----
if (material.uTexture[i]==0)
{
break;
}
}
if (material.uShader==-1)
{
material.uShader = GetShaderMgr().registerItem(material.getShader());
}
// ----
SetLightingEnabled(material.bLightingEnabled);
SetCullingMode((CullingMode)material.uCull);
// ----
SetAlphaTestFunc(material.bAlphaTest, (CompareFunction)material.nAlphaTestCompare, material.uAlphaTestValue);
SetBlendFunc(material.bBlend, (SceneBlendOperation)material.nBlendOP, (SceneBlendFactor)material.nBlendSrc, (SceneBlendFactor)material.nBlendDest);
SetDepthBufferFunc(material.bDepthTest,material.bDepthWrite);
// ----
if (0==material.uShader)
{
for (size_t i=0;i<8;++i)
{
CMaterial::TextureOP& texOP = material.textureOP[i];
SetTextureColorOP(i, (TextureBlendOperation)texOP.nColorOP, (TextureBlendSource)texOP.nColorSrc1, (TextureBlendSource)texOP.nColorSrc2);
SetTextureColorOP(i, (TextureBlendOperation)texOP.nAlphaOP, (TextureBlendSource)texOP.nAlphaSrc1, (TextureBlendSource)texOP.nAlphaSrc2);
if (TBOP_DISABLE == texOP.nColorOP)
{
break;
}
}
}
else
{
CShader* pShader = GetShaderMgr().getSharedShader();
if (pShader)
{
// for Terrain
pShader->setVec2D("g_fScaleUV",material.vUVScale);
}
SetShader(material.uShader);
}
return true;
/* if (material.bLightingEnabled)
{
SetMaterial(material.vAmbient,material.vDiffuse);
}
if (0==material.uShader)
{
//SetSamplerAddressUV(0,ADDRESS_WRAP,ADDRESS_WRAP);
if (material.vTexAnim.lengthSquared()>0.0f)
{
Matrix matTex=Matrix::UNIT;
float fTime = (float)GetGlobalTimer().GetTime();
matTex._13=fTime*material.vTexAnim.x;
matTex._23=fTime*material.vTexAnim.y;
setTextureMatrix(0, TTF_COUNT3, matTex);
}
Color32 cFactor = material.cEmissive;
if (material.m_fOpacity<0.0f)
{
fOpacity = (float)(rand()%255)/255.0f;
}
else
{
fOpacity *= material.m_fOpacity;
}
if (material.uDiffuse)
{
SetTexture(0, material.uDiffuse);
cFactor.a=(unsigned char)(cFactor.a*fOpacity);
SetTextureFactor(cFactor);
if (material.bLightingEnabled)
{
SetTextureColorOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_DIFFUSE);
}
else
{
SetTextureColorOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_TFACTOR);
}
if(material.bBlend||material.m_fOpacity<1.0f)
{
SetBlendFunc(true, BLENDOP_ADD, SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
}
if (material.m_fOpacity<1.0f)
{
SetTextureAlphaOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_TFACTOR);
}
else if (material.bAlphaTest||material.bBlend)
{
SetTextureAlphaOP(0, TBOP_SOURCE1, TBS_TEXTURE);
}
else
{
SetTextureAlphaOP(0, TBOP_DISABLE);
}
//////////////////////////////////////////////////////////////////////////
if (material.uSpecular)
{
SetTexture(1, material.uSpecular);
SetTextureColorOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_DIFFUSE);
setResultARGToTemp(1,true);
SetTextureColorOP(1, TBOP_MODULATE_X2, TBS_TEXTURE, TBS_SPECULAR);
SetTextureColorOP(2, TBOP_ADD, TBS_CURRENT, TBS_TEMP);
SetTexCoordIndex(0,0);
SetTexCoordIndex(1,0);
SetTexCoordIndex(2,0);
}
else if (material.uReflection)
{
SetTextureColorOP(1, TBOP_MODULATE_X2, TBS_CURRENT, TBS_TEXTURE);
SetTexCoordIndex(1,TCI_CAMERASPACE_NORMAL|TCI_CAMERASPACE_POSITION);
SetTexture(1, material.uReflection);
}
else if (material.uLightMap)
{
SetTextureColorOP(1, TBOP_MODULATE, TBS_CURRENT, TBS_TEXTURE);
SetTexCoordIndex(1,1);
SetTexture(1, material.uLightMap);
}
else if (material.uEmissive)
{
SetTextureColorOP(1, TBOP_ADD, TBS_CURRENT, TBS_TEXTURE);
SetTexture(1, material.uEmissive);
}
else if(!material.bBlend&&material.m_fOpacity>=1.0f)
{
SetTextureColorOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_DIFFUSE);
}
}
else
{
SetTextureFactor(cFactor);
if (material.uSpecular)
{
//SetTexture(0, material.uSpecular);
SetTextureColorOP(0, TBOP_SOURCE1, TBS_SPECULAR);
SetTexCoordIndex(0,0);
}
else if(material.uReflection)
{
cFactor.r=(unsigned char)(cFactor.r*fOpacity);
cFactor.g=(unsigned char)(cFactor.g*fOpacity);
cFactor.b=(unsigned char)(cFactor.b*fOpacity);
SetTextureFactor(cFactor);
if (material.bBlend)
{
SetBlendFunc(true, BLENDOP_ADD, SBF_DEST_COLOUR, SBF_ONE);
}
SetTextureColorOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_TFACTOR);
SetTextureAlphaOP(0, TBOP_DISABLE);
SetTexCoordIndex(0,TCI_CAMERASPACE_NORMAL|TCI_CAMERASPACE_POSITION);
SetTexture(0, material.uReflection);
}
else if (material.uLightMap)
{
if (material.bBlend)
{
SetBlendFunc(true, BLENDOP_ADD, SBF_DEST_COLOUR, SBF_ZERO);
}
SetTextureColorOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_TFACTOR);
SetTextureAlphaOP(0, TBOP_DISABLE);
SetTexture(0, material.uLightMap);
}
else if (material.uEmissive)
{
cFactor.r=(unsigned char)(cFactor.r*fOpacity);
cFactor.g=(unsigned char)(cFactor.g*fOpacity);
cFactor.b=(unsigned char)(cFactor.b*fOpacity);
SetTextureFactor(cFactor);
if (material.bBlend)
{
SetBlendFunc(true, BLENDOP_ADD, SBF_ONE, SBF_ONE);
}
SetTextureColorOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_TFACTOR);
SetTextureAlphaOP(0, TBOP_DISABLE);
SetTexture(0, material.uEmissive);
}
else if (material.uNormal)
{
CShader* pShader = GetShaderMgr().getSharedShader();
if (pShader)
{
static size_t s_uShaderID = GetShaderMgr().registerItem("EngineRes\\fx\\SpaceBump.fx");
pShader->setTexture("g_texNormal",material.uNormal);
SetShader(s_uShaderID);
}
//SetBlendFunc(true, BLENDOP_ADD, SBF_DEST_COLOUR, SBF_ZERO);
//SetTextureColorOP(0, TBOP_MODULATE, TBS_TEXTURE, TBS_TFACTOR);
//SetTextureAlphaOP(0, TBOP_DISABLE);
//SetTexture(0, uLightMap);
}
else
{
SetTextureColorOP(0,TBOP_SOURCE2);
if (material.bBlend)
{
SetTextureAlphaOP(0,TBOP_SOURCE2);
}
else
{
SetTextureAlphaOP(0,TBOP_DISABLE);
}
//return false;
}
}
}
else
{
CShader* pShader = GetShaderMgr().getSharedShader();
if (pShader)
{
pShader->setTexture("g_texDiffuse",material.uDiffuse);
pShader->setTexture("g_texLight",material.uLightMap);
pShader->setTexture("g_texNormal",material.uNormal);
//pShader->setTexture("g_texEnvironment",uEmissive);
//pShader->setTexture("g_texEmissive",uEmissive);
pShader->setTexture("g_texSpecular",material.uSpecular);
// for Terrain
pShader->setVec2D("g_fScaleUV",material.vUVScale);
}
SetShader(material.uShader);
}
return true;*/
}
CModelSurface::CModelSurface():
_vertexBuffer(0),
_indexBuffer(0),
_dirty(~0){
SetShader( App.ShaderUtil()->ModelShader() );
}
GaussianBlurRender::~GaussianBlurRender()
{
SetColorTex(0);
SetShader(0);
}
Material::Material()
{
SetShader(SHADER_TYPE_VERTEXSHADER, "Resources/Shaders/default_shader.vs");
SetShader(SHADER_TYPE_FRAGMENTSHADER, "Resources/Shaders/default_shader.fs");
SetShader(SHADER_TYPE_GEOMETRYSHADER, "Resources/Shaders/default_shader.gs");
}
mitk::ShaderProperty::ShaderProperty( const std::string& value )
{
AddShaderTypes();
SetShader(value);
}
void object::render()
{
SetShader();
d3ddevice->SetVertexShaderConstant( 0, &D3DXVECTOR4(0,0,0,0), 1 );
d3ddevice->SetVertexShaderConstant( 1, &D3DXVECTOR4(1,1,1,1), 1 );
d3ddevice->SetVertexShaderConstant( 80, &D3DXVECTOR4(0.5f,0.5f,0.5f,0.5f), 1 );
D3DXMATRIX mat;
D3DXMATRIX matworldview;
D3DXMATRIX temp;
D3DXVECTOR4 light_vec;
//D3DXVECTOR4 eye_vec;
D3DXMatrixIdentity(&matworld);
D3DXMatrixTranslation(&temp,radius_of_rotation,0,0);
D3DXMatrixMultiply( &matworld, &matworld, &temp );
D3DXMatrixRotationY(&temp,angle);
D3DXMatrixMultiply( &matworld, &matworld, &temp );
D3DXMatrixTranslation(&temp,center_pos.x,center_pos.y,center_pos.z);
D3DXMatrixMultiply( &matworld, &matworld, &temp );
D3DXMatrixMultiply( &matworldview, &matworld, &matView );
D3DXMatrixMultiply( &mat, &matworldview, &matProj );
D3DXMatrixTranspose( &mat, &mat );
d3ddevice->SetVertexShaderConstant( 2, &mat, 4 );
D3DXMatrixInverse(&temp,NULL,&matworld);
light_vec.x = light_pos[0];
light_vec.y = light_pos[1];
light_vec.z = light_pos[2];
light_vec.w = 1;
eye_pos.x = 0;
eye_pos.y = 0;
eye_pos.z = -15;
eye_pos.w = 1;
D3DXVec4Transform(&light_vec,&light_vec,&temp);
D3DXVec4Transform(&eye_pos,&eye_pos,&temp);
//D3DXVec3Normalize(&light_vec,&light_vec);
//D3DXMatrixTranspose( &temp, &temp );
//d3ddevice->SetVertexShaderConstant( 6, &temp, 4 );
// Declare and define the constant vertex color.
D3DXVECTOR4 diff_color;
diff_color = color;
diff_color *= diffuse_amount;
diff_color.w = 1;
d3ddevice->SetVertexShaderConstant( 10, &color, 1 );
d3ddevice->SetPixelShaderConstant( 2, &diff_color, 1 );
D3DXVECTOR4 spec_color;
spec_color = color;
spec_color += D3DXVECTOR4(1,1,1,1);
spec_color *= 0.5;
spec_color *= specular_amount;
spec_color.w = 1;
d3ddevice->SetPixelShaderConstant( 4, &spec_color, 1 );
d3ddevice->SetVertexShaderConstant( 11, &light_vec, 1 );
d3ddevice->SetVertexShaderConstant( 13, &eye_pos, 1 );
d3ddevice->SetVertexShaderConstant( 12, &ambient, 1 );
D3DXVECTOR4 amb_color;
amb_color = diff_color+spec_color;
amb_color *= 0.1f;
//amb_color.x *= color[0];
//amb_color.y *= color[1];
//amb_color.z *= color[2];
amb_color.w = 1;
d3ddevice->SetPixelShaderConstant( 3, &amb_color, 1 );
//d3ddevice->SetPixelShaderConstant( 5, &D3DXVECTOR4(0,0,0,0), 1 );
//set texture
if(texture != NULL)
d3ddevice->SetTexture(0,texture);
if(power_texture != NULL)
d3ddevice->SetTexture(1,power_texture);
d3ddevice->SetStreamSource( 0, vertex_buffer, sizeof(CUSTOMVERTEX) );
d3ddevice->SetIndices(index_buffer,0);
d3ddevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0,size, 0,size2);
//mesh->DrawSubset(1);
}
mitk::ShaderProperty::ShaderProperty( )
{
AddShaderTypes();
SetShader( (IdType)0 );
}
mitk::ShaderProperty::ShaderProperty( const IdType& value )
{
AddShaderTypes();
SetShader(value);
}
/* Draws primitives on screen
*/
void D3DRenderer::OnDrawBatch(const Otter::DrawBatch& batch)
{
mModel = *(D3DXMATRIX*)&batch.mTransform;
LPDIRECT3DTEXTURE9 texture = mTextureManager.GetTexture(batch.mTextureID);
const Otter::Property* pSetShader = batch.mProperties.GetProperty(SHADER_SET);
if(pSetShader)
{
uint32 newShader = (uint32)pSetShader->mData;
SetShader(newShader, false);
}
Shader& shader = mShaders[mCurrentShaderID];
const Otter::Property* pShaderParamCount = batch.mProperties.GetProperty(SHADER_PARAM_COUNT);
if(pShaderParamCount)
{
uint32 cnt = (uint32)pShaderParamCount->mData;
for(uint32 i = 0; i < cnt; i++)
{
const Otter::Property* pParamType = batch.mProperties.GetProperty(SHADER_PARAM_TYPE + i);
const Otter::Property* pParamID = batch.mProperties.GetProperty(SHADER_PARAM_ID + i);
const Otter::Property* pParamData = batch.mProperties.GetProperty(SHADER_PARAM_DATA + i);
const Otter::Property* pParamDataLen = batch.mProperties.GetProperty(SHADER_PARAM_DATA_LEN + i);
if(pParamType == NULL || pParamID == NULL || pParamData == NULL)
break;
if(pParamType->mData == 0) // Texture
{
shader.mEffect->SetTexture(shader.GetParameterHandle((int)pParamID->mData), mTextureManager.GetTexture(pParamData->mData));
}
else if(pParamType->mData == 1 && pParamDataLen != NULL) // Float Array
{
shader.mEffect->SetFloatArray(shader.GetParameterHandle((int)pParamID->mData), (float*)pParamData->mData, (int)pParamDataLen->mData);
}
else if(pParamType->mData == 2 && pParamDataLen != NULL) // Int Array
{
shader.mEffect->SetIntArray(shader.GetParameterHandle((int)pParamID->mData), (int*)pParamData->mData, (int)pParamDataLen->mData);
}
else if(pParamType->mData == 3) // Int
{
shader.mEffect->SetInt(shader.GetParameterHandle((int)pParamID->mData), (int)pParamData->mData);
}
}
}
const Otter::Property* pTechnique = batch.mProperties.GetProperty(SHADER_TECHNIQUE);
if(pTechnique)
shader.mEffect->SetTechnique((const char*)pTechnique->mData);
else
shader.mEffect->SetTechnique(texture != NULL ? "WithTexture" : "WithoutTexture");
shader.mEffect->SetTexture("DIFFUSE_TEXTURE", texture);
shader.mEffect->SetMatrix("MATRIX_MODEL", &mModel);
float lodBias = -1.0f;
if(texture != NULL)
{
int numLevels = texture->GetLevelCount();
mD3DDevice->SetSamplerState(0, D3DSAMP_MIPMAPLODBIAS, *(DWORD*)&lodBias);
}
if(batch.mRenderFlags & Otter::kRender_Wireframe)
{
mD3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
}
else
{
mD3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
}
uint32 passes = 0;
shader.mEffect->Begin(&passes, D3DXFX_DONOTSAVESAMPLERSTATE);
{
for(uint32 pass = 0; pass < passes; pass++)
{
shader.mEffect->BeginPass(pass);
D3DPRIMITIVETYPE primType = D3DPT_TRIANGLELIST;
switch(batch.mPrimitiveType)
{
case Otter::kPrim_TriangleFan:
{
primType = D3DPT_TRIANGLEFAN;
break;
}
case Otter::kPrim_TriangleStrip:
{
primType = D3DPT_TRIANGLESTRIP;
break;
}
}
mD3DDevice->DrawPrimitive(primType, batch.mVertexStartIndex, batch.mPrimitiveCount);
shader.mEffect->EndPass();
}
}
shader.mEffect->End();
}
Band::Band(const unsigned int max_length)
: band_width_(0.2), max_length_(max_length) {
SetShader();
vertices_v_.reserve(max_length);
}
void cRendererGLES2::SetShader( const EEGLES2_SHADERS& Shader ) {
SetShader( mShaders[ Shader ] );
}
void Graphic::DrawTexture(TEXTURE_ID id, const Vector2 pos, Vector2 size, D3DXCOLOR color, Vector2 center, float left, float top, float right, float bottom, float angle){
SetShader(SHADER_ID::TEXTURE_SHADER);
Matrix4 mat = RCMatrix4::Identity();
texture[id].Draw(vector3(pos.x, pos.y, 0), vector3(size.x, size.y, 0), vector3(center.x, center.y, 0.0f), left, top, right, bottom, &shader[sID], color, angle);
animBind = false;
}
/*
================
idLight::BecomeBroken
================
*/
void idLight::BecomeBroken( idEntity *activator )
{
const char *damageDefName;
fl.takedamage = false;
if ( brokenModel.Length() )
{
SetModel( brokenModel );
if ( !spawnArgs.GetBool( "nonsolid" ) )
{
GetPhysics()->SetClipModel( new idClipModel( brokenModel.c_str() ), 1.0f );
GetPhysics()->SetContents( CONTENTS_SOLID );
}
}
else if ( spawnArgs.GetBool( "hideModelOnBreak" ) )
{
SetModel( "" );
GetPhysics()->SetContents( 0 );
}
if ( gameLocal.isServer )
{
ServerSendEvent( EVENT_BECOMEBROKEN, NULL, true, -1 );
if ( spawnArgs.GetString( "def_damage", "", &damageDefName ) )
{
idVec3 origin = renderEntity.origin + renderEntity.bounds.GetCenter() * renderEntity.axis;
gameLocal.RadiusDamage( origin, activator, activator, this, this, damageDefName );
}
}
ActivateTargets( activator );
// offset the start time of the shader to sync it to the game time
renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
renderLight.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
// set the state parm
renderEntity.shaderParms[ SHADERPARM_MODE ] = 1;
renderLight.shaderParms[ SHADERPARM_MODE ] = 1;
// if the light has a sound, either start the alternate (broken) sound, or stop the sound
const char *parm = spawnArgs.GetString( "snd_broken" );
if ( refSound.shader || ( parm && *parm ) )
{
StopSound( SND_CHANNEL_ANY, false );
const idSoundShader *alternate = refSound.shader ? refSound.shader->GetAltSound() : declManager->FindSound( parm );
if ( alternate )
{
// start it with no diversity, so the leadin break sound plays
refSound.referenceSound->StartSound( alternate, SND_CHANNEL_ANY, 0.0, 0 );
}
}
parm = spawnArgs.GetString( "mtr_broken" );
if ( parm && *parm )
{
SetShader( parm );
}
UpdateVisuals();
}
void Graphic::DrawFontDirect(FONT_ID id, const Vector2 pos, Vector2 size, float range, std::string s, const Vector3 color, const float alpha, bool center){
SetShader(SHADER_ID::FONT_SHADER);
font[id].Draw(pos, size, range, &shader[sID], s, &D3DXCOLOR(color.x, color.y,color.z, alpha),center);
animBind = false;
}
const bool Canodumb::Hit(int _damage) {
(health - _damage < 0) ? health = 0 : health -= _damage;
SetShader(whiteout);
return health;
}
void WINAPI QERApp_ReloadShaderFile (const char *name)
{
brush_t *b;
face_t *f;
brush_t *active_brushes;
brush_t *selected_brushes;
brush_t *filtered_brushes;
// Sys_Printf("TODO: QERApp_ReloadShaderFile\n");
active_brushes = g_DataTable.m_pfnActiveBrushes ();
selected_brushes = g_DataTable.m_pfnSelectedBrushes ();
filtered_brushes = g_DataTable.m_pfnFilteredBrushes ();
#ifdef _DEBUG
// check the shader name is a reletive path
// I hacked together a few quick tests to make sure :-)
if (strstr (name, ":\\") || !strstr (name, "scripts"))
Sys_Printf ("WARNING: is %s a reletive path to a shader file? (QERApp_ReloadShaderFile\n");
#endif
// in the actives and global shaders lists, decref and unhook the shaders
//++timo NOTE: maybe we'd like to keep track of the shaders we are unhooking?
g_ActiveShaders.ReleaseForShaderFile (name);
g_Shaders.ReleaseForShaderFile (name);
// go through a reload of the shader file
QERApp_LoadShaderFile (name);
// scan all the brushes, replace all the old ones by refs to their new equivalents
for (b = active_brushes->next; b != NULL && b != active_brushes; b = b->next)
{
if (b->patchBrush && !strcmp (b->pPatch->pShader->getShaderFileName (), name))
SetShader (b->pPatch);
else
for (f = b->brush_faces; f; f = f->next)
if (!strcmp (f->pShader->getShaderFileName (), name))
SetShader (f);
}
for (b = selected_brushes->next; b != NULL && b != selected_brushes; b = b->next)
{
if (b->patchBrush && !strcmp (b->pPatch->pShader->getShaderFileName (), name))
SetShader (b->pPatch);
else
for (f = b->brush_faces; f; f = f->next)
if (!strcmp (f->pShader->getShaderFileName (), name))
SetShader (f);
}
// do that to the filtered brushes as well (we might have some region compiling going on)
for (b = filtered_brushes->next; b != NULL && b != filtered_brushes; b = b->next)
{
if (b->patchBrush && !strcmp (b->pPatch->pShader->getShaderFileName (), name))
SetShader (b->pPatch);
else
for (f = b->brush_faces; f; f = f->next)
if (!strcmp (f->pShader->getShaderFileName (), name))
SetShader (f);
}
// call Texture_ShowInUse to clean and display only what's required
g_ShadersTable.m_pfnTexture_ShowInuse ();
QERApp_SortActiveShaders ();
g_FuncTable.m_pfnSysUpdateWindows (W_TEXTURE);
}
int CMQOMaterial::SetParams( int srcno, ARGBF sceneamb, char* srcchar, int srcleng )
{
//"肌色" col(1.000 0.792 0.651 1.000) dif(0.490) amb(0.540) emi(0.530) spc(0.020) power(0.00)
//DbgOut( "check!!!: mqomat : SetParams : %d, %s, %d\r\n", srcno, srcchar, srcleng );
materialno = srcno;
m_sceneamb = sceneamb;//!!!!!!!!!!!!!!!!!
char pat[12][20] =
{
"col(",
"dif(",
"amb(",
"emi(",
"spc(",
"power(",
"tex(",
"alpha(",
"bump(",
"shader(",
"vcol(",
"\"" //！！！tex, alpha, bumpよりも後でないとだめ。
};
int pos = 0;
int stepnum;
int ret;
while( pos < srcleng ){
while( (pos < srcleng) &&
( (*(srcchar + pos) == ' ') || (*(srcchar + pos) == '\t') )
){
pos++;
}
int cmp;
int patno, patleng;
int isfind = 0;
for( patno = 0; patno < 12; patno++ ){
if( isfind == 1 )
break;
patleng = (int)strlen( pat[patno] );
if( srcleng - pos >= patleng ){
cmp = strncmp( pat[patno], srcchar + pos, patleng );
if( cmp == 0 ){
isfind = 1;
switch( patno ){
case 0:
ret = SetCol( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 1:
ret = SetDif( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 2:
ret = SetAmb( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 3:
ret = SetEmi( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 4:
ret = SetSpc( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 5:
ret = SetPower( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 6:
ret = SetTex( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 7:
ret = SetAlpha( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 8:
ret = SetBump( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 9:
ret = SetShader( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 10:
ret = SetVcolFlag( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
case 11:
//DbgOut( "MQOMaterial : SetParams : SetName %d\n", pos );
ret = SetName( srcchar, pos, srcleng, &stepnum );
if( ret )
return ret;
break;
default:
_ASSERT( 0 );
return 1;
break;
}
}
}
}
if( isfind == 1 ){
pos += stepnum;
}else{
pos++;
}
}
ret = ConvParamsTo3F();
_ASSERT( !ret );
return 0;
}
bool VertexShaderCache::SetShader(D3DVertexFormat* vertex_format)
{
if (g_ActiveConfig.bDisableSpecializedShaders)
return SetUberShader(vertex_format);
VertexShaderUid uid = GetVertexShaderUid();
if (last_entry && uid == last_uid)
{
if (last_entry->pending)
return SetUberShader(vertex_format);
if (!last_entry->shader)
return false;
vertex_format->SetInputLayout(last_entry->bytecode);
D3D::stateman->SetVertexShader(last_entry->shader);
return true;
}
auto iter = vshaders.find(uid);
if (iter != vshaders.end())
{
const VSCacheEntry& entry = iter->second;
if (entry.pending)
return SetUberShader(vertex_format);
last_uid = uid;
last_entry = &entry;
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
if (!last_entry->shader)
return false;
vertex_format->SetInputLayout(last_entry->bytecode);
D3D::stateman->SetVertexShader(last_entry->shader);
return true;
}
// Background compiling?
if (g_ActiveConfig.CanBackgroundCompileShaders())
{
// Create a pending entry
VSCacheEntry entry;
entry.pending = true;
vshaders[uid] = entry;
// Queue normal shader compiling and use ubershader
g_async_compiler->QueueWorkItem(
g_async_compiler->CreateWorkItem<VertexShaderCompilerWorkItem>(uid));
return SetUberShader(vertex_format);
}
// Need to compile a new shader
D3DBlob* bytecode = nullptr;
ShaderCode code =
GenerateVertexShaderCode(APIType::D3D, ShaderHostConfig::GetCurrent(), uid.GetUidData());
D3D::CompileVertexShader(code.GetBuffer(), &bytecode);
if (!InsertByteCode(uid, bytecode))
{
SAFE_RELEASE(bytecode);
return false;
}
g_vs_disk_cache.Append(uid, bytecode->Data(), bytecode->Size());
bytecode->Release();
return SetShader(vertex_format);
}
bool Lighting::EvaluateLighting(LPDIRECT3DDEVICE9 Device, RenderMesh *RMesh, ShaderMat *Mat)
{
D3DLIGHT9 DLight;
D3DXVECTOR3 Pos,Dir;
RenderLight Light;
int i;
if(!Device || !RMesh || !m_Ready)
{
return(false);
}
m_Device = Device;
//
// Setup
//
// The force update is used when the scene is in an unknwon state - usual after a an undo of a light
if(m_forceUpdate)
GetLightsFromScene();
UpdateLights();
SetRenderStates();
// m_Lights.clear();
if(m_Lights.size())
{
for(i=0; i < m_Lights.size(); i++)
{
SetShader(m_Lights[i].m_Type,Mat);
SetMaterialConst(Mat);
SetShaderConst(i,&m_Lights[i],Mat);
RMesh->Render(m_Device);
}
}
else
{
m_Device->GetLight(0,&DLight);
Light.m_Dir = Point3(-DLight.Direction.x,
-DLight.Direction.y,
-DLight.Direction.z);
Light.m_Color.x = DLight.Diffuse.r;
Light.m_Color.y = DLight.Diffuse.g;
Light.m_Color.z = DLight.Diffuse.b;
Light.m_Pos.x = DLight.Position.x;
Light.m_Pos.y = DLight.Position.y;
Light.m_Pos.z = DLight.Position.z;
Light.m_InnerRange = 1.0f;
Light.m_OuterRange = 1.0f / (DLight.Range * 2.0f);
SetShader(LIGHT_DIR,Mat);
SetMaterialConst(Mat);
SetShaderConst(0,&Light,Mat);
RMesh->Render(m_Device);
}
return(true);
}
Material(Shader::PShader shader) {
SetShader(shader);
}
int ContextD3D11::PushVertexShader(VertexShader* ptr) {
if (shaders_.vs != nullptr)
shaders_.vs_list.push_back(shaders_.vs);
SetShader(*ptr);
return S_OK;
}
void nuiDrawContext::StopRendering()
{
SetTexture(NULL);
SetShader(NULL, NULL);
}
int ContextD3D11::PushPixelShader(PixelShader* ptr) {
if (shaders_.ps != nullptr)
shaders_.ps_list.push_back(shaders_.ps);
SetShader(*ptr);
return S_OK;
}
/*
================
idLight::Event_SetShader
================
*/
void idLight::Event_SetShader( const char *shadername ) {
SetShader( shadername );
}
void FRCPassPostProcessDeferredDecals::Process(FRenderingCompositePassContext& Context)
{
FRHICommandListImmediate& RHICmdList = Context.RHICmdList;
const bool bShaderComplexity = Context.View.Family->EngineShowFlags.ShaderComplexity;
const bool bDBuffer = IsDBufferEnabled();
const bool bStencilSizeThreshold = CVarStencilSizeThreshold.GetValueOnRenderThread() >= 0;
SCOPED_DRAW_EVENT(RHICmdList, PostProcessDeferredDecals);
if(RenderStage == 0)
{
// before BasePass, only if DBuffer is enabled
check(bDBuffer);
// DBuffer: Decal buffer
FPooledRenderTargetDesc Desc(FPooledRenderTargetDesc::Create2DDesc(GSceneRenderTargets.GBufferA->GetDesc().Extent,
PF_B8G8R8A8,
TexCreate_None,
TexCreate_ShaderResource | TexCreate_RenderTargetable,
false));
if(!GSceneRenderTargets.DBufferA)
{
GRenderTargetPool.FindFreeElement(Desc, GSceneRenderTargets.DBufferA, TEXT("DBufferA"));
}
if(!GSceneRenderTargets.DBufferB)
{
GRenderTargetPool.FindFreeElement(Desc, GSceneRenderTargets.DBufferB, TEXT("DBufferB"));
}
Desc.Format = PF_R8G8;
if(!GSceneRenderTargets.DBufferC)
{
GRenderTargetPool.FindFreeElement(Desc, GSceneRenderTargets.DBufferC, TEXT("DBufferC"));
}
// we assume views are non overlapping, then we need to clear only once in the beginning, otherwise we would need to set scissor rects
// and don't get FastClear any more.
bool bFirstView = Context.View.Family->Views[0] == &Context.View;
if(bFirstView)
{
SCOPED_DRAW_EVENT(RHICmdList, DBufferClear);
// could be optimized
SetRenderTarget(RHICmdList, GSceneRenderTargets.DBufferA->GetRenderTargetItem().TargetableTexture, FTextureRHIParamRef());
RHICmdList.Clear(true, FLinearColor(0, 0, 0, 1), false, (float)ERHIZBuffer::FarPlane, false, 0, FIntRect());
SetRenderTarget(RHICmdList, GSceneRenderTargets.DBufferB->GetRenderTargetItem().TargetableTexture, FTextureRHIParamRef());
// todo: some hardware would like to have 0 or 1 for faster clear, we chose 128/255 to represent 0 (8 bit cannot represent 0.5f)
RHICmdList.Clear(true, FLinearColor(128.0f / 255.0f, 128.0f / 255.0f, 128.0f / 255.0f, 1), false, (float)ERHIZBuffer::FarPlane, false, 0, FIntRect());
SetRenderTarget(RHICmdList, GSceneRenderTargets.DBufferC->GetRenderTargetItem().TargetableTexture, FTextureRHIParamRef());
// R:roughness, G:roughness opacity
RHICmdList.Clear(true, FLinearColor(0, 1, 0, 1), false, (float)ERHIZBuffer::FarPlane, false, 0, FIntRect());
}
}
// this cast is safe as only the dedicated server implements this differently and this pass should not be executed on the dedicated server
const FViewInfo& View = Context.View;
const FSceneViewFamily& ViewFamily = *(View.Family);
FScene& Scene = *(FScene*)ViewFamily.Scene;
if(!Scene.Decals.Num())
{
// to avoid the stats showing up
return;
}
TArray<FTransientDecalRenderData, SceneRenderingAllocator> SortedDecals;
SortedDecals.Empty(Scene.Decals.Num());
// Build a list of decals that need to be rendered for this view in SortedDecals
for (TSparseArray<FDeferredDecalProxy*>::TConstIterator It(Scene.Decals); It; ++It)
{
FDeferredDecalProxy* DecalProxy = *It;
bool bIsShown = true;
// Handle the decal actor having bHidden set when we are in the editor, in G mode
#if WITH_EDITOR
if (View.Family->EngineShowFlags.Editor)
#endif
{
if (!DecalProxy->DrawInGame)
{
bIsShown = false;
}
}
const FMatrix ComponentToWorldMatrix = DecalProxy->ComponentTrans.ToMatrixWithScale();
// can be optimized as we test against a sphere around the box instead of the box itself
const float ConservativeRadius = FMath::Sqrt(
ComponentToWorldMatrix.GetScaledAxis( EAxis::X ).SizeSquared() * FMath::Square(GDefaultDecalSize.X) +
ComponentToWorldMatrix.GetScaledAxis( EAxis::Y ).SizeSquared() * FMath::Square(GDefaultDecalSize.Y) +
ComponentToWorldMatrix.GetScaledAxis( EAxis::Z ).SizeSquared() * FMath::Square(GDefaultDecalSize.Z));
// can be optimized as the test is too conservative (sphere instead of OBB)
if(ConservativeRadius < SMALL_NUMBER || !View.ViewFrustum.IntersectSphere(ComponentToWorldMatrix.GetOrigin(), ConservativeRadius))
{
bIsShown = false;
}
if (bIsShown)
{
FTransientDecalRenderData Data(Scene, DecalProxy);
uint32 DecalRenderStage = ComputeRenderStage(Data.DecalBlendMode);
// we could do this test earlier to avoid the decal intersection but getting DecalBlendMode also costs
if (Context.View.Family->EngineShowFlags.ShaderComplexity || RenderStage == DecalRenderStage)
{
SortedDecals.Add(Data);
}
}
}
if(SortedDecals.Num() > 0)
{
FIntRect SrcRect = View.ViewRect;
FIntRect DestRect = View.ViewRect;
bool bStencilDecals = true;
#if DBUFFER_DONT_USE_STENCIL_YET
if(RenderStage == 0)
{
bStencilDecals = false;
}
#endif
// Setup a stencil mask to prevent certain pixels from receiving deferred decals
if(bStencilDecals)
{
StencilDecalMask(RHICmdList, View);
}
// Sort by sort order to allow control over composited result
// Then sort decals by state to reduce render target switches
// Also sort by component since Sort() is not stable
struct FCompareFTransientDecalRenderData
{
FORCEINLINE bool operator()( const FTransientDecalRenderData& A, const FTransientDecalRenderData& B ) const
{
if (B.DecalProxy->SortOrder != A.DecalProxy->SortOrder)
{
return A.DecalProxy->SortOrder < B.DecalProxy->SortOrder;
}
if (B.DecalBlendMode != A.DecalBlendMode)
{
return (int32)B.DecalBlendMode < (int32)A.DecalBlendMode;
}
if (B.bHasNormal != A.bHasNormal)
{
return B.bHasNormal < A.bHasNormal;
}
// Batch decals with the same material together
if (B.MaterialProxy != A.MaterialProxy )
{
return B.MaterialProxy < A.MaterialProxy;
}
return (PTRINT)B.DecalProxy->Component < (PTRINT)A.DecalProxy->Component;
}
};
// Sort decals by blend mode to reduce render target switches
SortedDecals.Sort( FCompareFTransientDecalRenderData() );
// optimization to have less state changes
int32 LastDecalBlendMode = -1;
int32 LastDecalHasNormal = -1; // Decal state can change based on its normal property.(SM5)
ERenderTargetMode LastRenderTargetMode = RTM_Unknown;
int32 WasInsideDecal = -1;
const ERHIFeatureLevel::Type SMFeatureLevel = Context.GetFeatureLevel();
SCOPED_DRAW_EVENT(RHICmdList, Decals);
INC_DWORD_STAT_BY(STAT_Decals, SortedDecals.Num());
enum EDecalResolveBufferIndex
{
SceneColorIndex,
GBufferAIndex,
GBufferBIndex,
GBufferCIndex,
DBufferAIndex,
DBufferBIndex,
DBufferCIndex,
ResolveBufferMax,
};
FTextureRHIParamRef TargetsToResolve[ResolveBufferMax] = { nullptr };
for (int32 DecalIndex = 0, DecalCount = SortedDecals.Num(); DecalIndex < DecalCount; DecalIndex++)
{
const FTransientDecalRenderData& DecalData = SortedDecals[DecalIndex];
const FDeferredDecalProxy& DecalProxy = *DecalData.DecalProxy;
const FMatrix ComponentToWorldMatrix = DecalProxy.ComponentTrans.ToMatrixWithScale();
// Set vertex shader params
const FMaterialShaderMap* MaterialShaderMap = DecalData.MaterialResource->GetRenderingThreadShaderMap();
FScaleMatrix DecalScaleTransform(GDefaultDecalSize);
FTranslationMatrix PreViewTranslation(View.ViewMatrices.PreViewTranslation);
FMatrix FrustumComponentToClip = DecalScaleTransform * ComponentToWorldMatrix * PreViewTranslation * View.ViewMatrices.TranslatedViewProjectionMatrix;
// can be optimized as we test against a sphere around the box instead of the box itself
const float ConservativeRadius = FMath::Sqrt(
ComponentToWorldMatrix.GetScaledAxis( EAxis::X ).SizeSquared() * FMath::Square(GDefaultDecalSize.X) +
ComponentToWorldMatrix.GetScaledAxis( EAxis::Y ).SizeSquared() * FMath::Square(GDefaultDecalSize.Y) +
ComponentToWorldMatrix.GetScaledAxis( EAxis::Z ).SizeSquared() * FMath::Square(GDefaultDecalSize.Z));
EDecalBlendMode DecalBlendMode = DecalData.DecalBlendMode;
bool bStencilThisDecal = bStencilDecals;
#if DBUFFER_DONT_USE_STENCIL_YET
if(ComputeRenderStage(DecalBlendMode) == 0)
{
bStencilThisDecal = false;
}
#endif
ERenderTargetMode CurrentRenderTargetMode = ComputeRenderTargetMode(DecalBlendMode);
if(bShaderComplexity)
{
CurrentRenderTargetMode = RTM_SceneColor;
// we want additive blending for the ShaderComplexity mode
DecalBlendMode = DBM_Emissive;
}
// fewer rendertarget switches if possible
if(CurrentRenderTargetMode != LastRenderTargetMode)
{
LastRenderTargetMode = CurrentRenderTargetMode;
switch(CurrentRenderTargetMode)
{
case RTM_SceneColorAndGBuffer:
{
TargetsToResolve[SceneColorIndex] = GSceneRenderTargets.GetSceneColor()->GetRenderTargetItem().TargetableTexture;
TargetsToResolve[GBufferAIndex] = GSceneRenderTargets.GBufferA->GetRenderTargetItem().TargetableTexture;
TargetsToResolve[GBufferBIndex] = GSceneRenderTargets.GBufferB->GetRenderTargetItem().TargetableTexture;
TargetsToResolve[GBufferCIndex] = GSceneRenderTargets.GBufferC->GetRenderTargetItem().TargetableTexture;
SetRenderTargets(RHICmdList, 4, TargetsToResolve, GSceneRenderTargets.GetSceneDepthSurface(), ESimpleRenderTargetMode::EExistingColorAndDepth, FExclusiveDepthStencil::DepthRead_StencilWrite);
}
break;
case RTM_GBufferNormal:
TargetsToResolve[GBufferAIndex] = GSceneRenderTargets.GBufferA->GetRenderTargetItem().TargetableTexture;
SetRenderTarget(RHICmdList, TargetsToResolve[GBufferAIndex], GSceneRenderTargets.GetSceneDepthSurface(), ESimpleRenderTargetMode::EExistingColorAndDepth, FExclusiveDepthStencil::DepthRead_StencilWrite);
break;
case RTM_SceneColor:
TargetsToResolve[SceneColorIndex] = GSceneRenderTargets.GetSceneColor()->GetRenderTargetItem().TargetableTexture;
SetRenderTarget(RHICmdList, TargetsToResolve[SceneColorIndex], GSceneRenderTargets.GetSceneDepthSurface(), ESimpleRenderTargetMode::EExistingColorAndDepth, FExclusiveDepthStencil::DepthRead_StencilWrite);
break;
case RTM_DBuffer:
{
TargetsToResolve[DBufferAIndex] = GSceneRenderTargets.DBufferA->GetRenderTargetItem().TargetableTexture;
TargetsToResolve[DBufferBIndex] = GSceneRenderTargets.DBufferB->GetRenderTargetItem().TargetableTexture;
TargetsToResolve[DBufferCIndex] = GSceneRenderTargets.DBufferC->GetRenderTargetItem().TargetableTexture;
SetRenderTargets(RHICmdList, 3, &TargetsToResolve[DBufferAIndex], GSceneRenderTargets.GetSceneDepthSurface(), ESimpleRenderTargetMode::EExistingColorAndDepth, FExclusiveDepthStencil::DepthRead_StencilWrite);
}
break;
default:
check(0);
break;
}
Context.SetViewportAndCallRHI(DestRect);
// we need to reset the stream source after any call to SetRenderTarget (at least for Metal, which doesn't queue up VB assignments)
RHICmdList.SetStreamSource(0, GUnitCubeVertexBuffer.VertexBufferRHI, sizeof(FVector4), 0);
}
bool bThisDecalUsesStencil = false;
if (bStencilThisDecal)
{
if (bStencilSizeThreshold)
{
// note this is after a SetStreamSource (in if CurrentRenderTargetMode != LastRenderTargetMode) call as it needs to get the VB input
bThisDecalUsesStencil = RenderPreStencil(Context, MaterialShaderMap, ComponentToWorldMatrix, FrustumComponentToClip);
WasInsideDecal = -1;
LastDecalBlendMode = -1;
}
}
const bool bBlendStateChange = DecalBlendMode != LastDecalBlendMode;// Has decal mode changed.
const bool bDecalNormalChanged = GSupportsSeparateRenderTargetBlendState && // has normal changed for SM5 stain/translucent decals?
(DecalBlendMode == DBM_Translucent || DecalBlendMode == DBM_Stain) &&
(int32)DecalData.bHasNormal != LastDecalHasNormal;
// fewer blend state changes if possible
if (bBlendStateChange || bDecalNormalChanged)
{
LastDecalBlendMode = DecalBlendMode;
LastDecalHasNormal = (int32)DecalData.bHasNormal;
SetDecalBlendState(RHICmdList, SMFeatureLevel, RenderStage, (EDecalBlendMode)LastDecalBlendMode, DecalData.bHasNormal);
}
{
TShaderMapRef<FDeferredDecalVS> VertexShader(Context.GetShaderMap());
SetShader(Context, bShaderComplexity, DecalData, *VertexShader);
VertexShader->SetParameters(RHICmdList, View, FrustumComponentToClip);
const int32 IsInsideDecal = ((FVector)View.ViewMatrices.ViewOrigin - ComponentToWorldMatrix.GetOrigin()).SizeSquared() < FMath::Square(ConservativeRadius * 1.05f + View.NearClippingDistance * 2.0f) + ( bThisDecalUsesStencil ) ? 2 : 0;
if ( WasInsideDecal != IsInsideDecal )
{
WasInsideDecal = IsInsideDecal;
if ( !(IsInsideDecal & 1) )
{
// Render backfaces with depth tests disabled since the camera is inside (or close to inside) the light function geometry
RHICmdList.SetRasterizerState(View.bReverseCulling ? TStaticRasterizerState<FM_Solid, CM_CCW>::GetRHI() : TStaticRasterizerState<FM_Solid, CM_CW>::GetRHI());
if(bStencilDecals)
{
// Enable stencil testing, only write to pixels with stencil of 0
if ( bThisDecalUsesStencil )
{
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<
false,CF_Always,
true,CF_Equal,SO_Zero,SO_Zero,SO_Zero,
true,CF_Equal,SO_Zero,SO_Zero,SO_Zero,
0xff, 0x7f
>::GetRHI(), 1);
}
else
{
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<
false,CF_Always,
true,CF_Equal,SO_Keep,SO_Keep,SO_Keep,
false,CF_Always,SO_Keep,SO_Keep,SO_Keep,
0x80,0x00>::GetRHI(), 0);
}
}
else
{
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always, true>::GetRHI(), 0);
}
}
else
{
// Render frontfaces with depth tests on to get the speedup from HiZ since the camera is outside the light function geometry
if(bStencilDecals)
{
// Render frontfaces with depth tests on to get the speedup from HiZ since the camera is outside the light function geometry
// Enable stencil testing, only write to pixels with stencil of 0
if ( bThisDecalUsesStencil )
{
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<
false,CF_DepthNearOrEqual,
true,CF_Equal,SO_Zero,SO_Zero,SO_Zero,
true,CF_Equal,SO_Zero,SO_Zero,SO_Zero,
0xff, 0x7f
>::GetRHI(), 1);
}
else
{
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<
false,CF_DepthNearOrEqual,
true,CF_Equal,SO_Keep,SO_Keep,SO_Keep,
false,CF_Always,SO_Keep,SO_Keep,SO_Keep,
0x80,0x00>::GetRHI(), 0);
}
RHICmdList.SetRasterizerState(View.bReverseCulling ? TStaticRasterizerState<FM_Solid, CM_CW>::GetRHI() : TStaticRasterizerState<FM_Solid, CM_CCW>::GetRHI());
}
else
{
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_DepthNearOrEqual>::GetRHI(), 0);
}
RHICmdList.SetRasterizerState(View.bReverseCulling ? TStaticRasterizerState<FM_Solid, CM_CW>::GetRHI() : TStaticRasterizerState<FM_Solid, CM_CCW>::GetRHI());
}
}
RHICmdList.DrawIndexedPrimitive(GUnitCubeIndexBuffer.IndexBufferRHI, PT_TriangleList, 0, 0, 8, 0, GUnitCubeIndexBuffer.GetIndexCount() / 3, 1);
}
}
// we don't modify stencil but if out input was having stencil for us (after base pass - we need to clear)
// Clear stencil to 0, which is the assumed default by other passes
RHICmdList.Clear(false, FLinearColor::White, false, (float)ERHIZBuffer::FarPlane, true, 0, FIntRect());
// resolve the targets we wrote to.
FResolveParams ResolveParams;
for (int32 i = 0; i < ResolveBufferMax; ++i)
{
if (TargetsToResolve[i])
{
RHICmdList.CopyToResolveTarget(TargetsToResolve[i], TargetsToResolve[i], true, ResolveParams);
}
}
}
if(RenderStage == 0)
{
// before BasePass
GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, GSceneRenderTargets.DBufferA);
GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, GSceneRenderTargets.DBufferB);
GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, GSceneRenderTargets.DBufferC);
}
}
