//-------------------------------------------------------------------------
public void create(CRenderScene scene, CRenderTurret render_turret)
{
mScene = scene;
mRenderTurret = render_turret;
mCSpriteTurretFort = new CSpriteTurretFort();
mCSpriteTurretFort.create(mScene, mRenderTurret);
mLinkLockedFishFeature = new LinkLockedFishFeature(mScene, mRenderTurret);
//mRateNumber = new CSpriteNumber(mScene, new CPanelDigitFactory(mScene));
//mRateNumber.create(0, mRateNumberPosition, mRateNumberAngel, CSpriteNumber._eNumberSize.Small1);
//mRateNumber.setTag("CSpriteTurret" + mRenderTurret.getTurretId());
//mRateNumber.setTrigger(true);
}
//-------------------------------------------------------------------------
public LevelBackgroundMgr(CRenderScene scene, CSpriteBackgroundLoader loader)
{
mScene = scene;
mBackgroundLoader = loader;
mSpeed = 960f / mMaxTime;
mWaveStillSprite = mScene.getRenderObjectPool().newStillSprite();
mWaveStillSprite.playAnimation("WaterWave");
mWaveStillSprite.setActive(false);
mWaveStillSprite.setScale(700f / 550f);
#if UNITY_EDITOR
mWaveStillSprite.gameObject.name = "TkSpriteWaterWave";
#endif
}
public void create(CRenderScene scene)
{
mScene = scene;
mStillSprites.Add(newSpriteBox(false, false, 2, 2));
mStillSprites.Add(newSpriteBox(true, false, 2, 2));
mStillSprites.Add(newSpriteBox(false, false, 2, 2));
mStillSprites.Add(newSpriteBox(false, true, 2, 2));
mStillSprites.Add(newSpriteBox(true, true, 2, 2));
mStillSprites.Add(newSpriteBox(false, true, 2, 2));
mStillSprites.Add(newSpriteBox(false, false, 2, 2));
mStillSprites.Add(newSpriteBox(true, false, 2, 2));
mStillSprites.Add(newSpriteBox(false, false, 2, 2));
}
//-------------------------------------------------------------------------
public void create(CRenderScene scene, CRenderBullet render_bullet, string animation_name, TbDataParticle hit_particle)
{
mScene = scene;
mBullet = render_bullet;
mHitParticle = hit_particle;
mStillSprite = mScene.getRenderObjectPool().newStillSprite();
mStillSprite.setTrigger(true);
mStillSprite.playAnimation(animation_name);
mStillSprite.onTriggerEnter += OnTriggerEnter;
#if UNITY_EDITOR
mStillSprite.gameObject.name = "TkSpriteBullet_" + animation_name;
#endif
mBoxY = mStillSprite.getBoxColliderSize().y;
}
public CRenderScene CreateRenderScene(IRenderSurface surface)
{
foreach (CRenderScene scene in m_renderScenes)
{
if (scene.SceneRenderer.Hwnd == surface.GetHWND())
{
return(null);
}
}
CRenderScene newScene = new CRenderScene();
newScene.InitScene(m_d3dRenderer.D3DDevice, m_d3dRenderer.D3DDeviceContext, surface);
newScene.DebugRenderer.Init(m_d3dRenderer.D3DDevice, m_d3dRenderer.UIRenderer.FontProvider);
newScene.SceneRenderer.UIContext = m_d3dRenderer.UIRenderer.CreateAdditionalContext();
m_renderScenes.Add(newScene);
return(newScene);
}
//-------------------------------------------------------------------------
public CSpriteScore(CRenderScene scene, EbVector3 position, float angle, int turret_no)
{
mScene = scene;
mSpriteNumber = new CSpriteNumber(mScene, new CPanelDigitFactory(mScene));
mSpriteNumber.create(0, position, angle, CSpriteNumber._eNumberSize.Small1, CSpriteNumber._eNumberAlign.Right);
mSpriteNumber.setLayer(mScene.getLayerAlloter().getLayer(_eLevelLayer.TurretScore));
mBackground = mScene.getRenderObjectPool().newStillSprite();
mBackground.playAnimation("score_panel_" + turret_no);
mBackground.setScale(1, 1f);
setScore(0);
#if UNITY_EDITOR
mBackground.gameObject.name = "TkSpriteSpriteScore_score_panel_" + turret_no;
#endif
}
//-------------------------------------------------------------------------
public void create(CRenderScene scene, CRenderTurret render_turret)
{
mScene = scene;
if (mScene.isBot())
{
return;
}
mCSpriteTurretScoreShow = new CSpriteTurretScoreShow();
mCSpriteTurretScoreShow.create(scene, render_turret);
mSpriteTurret = new CSpriteTurret();
mSpriteTurret.create(scene, render_turret);
mSpriteTurret.aimAt(render_turret.getTurretAngle());
mSpriteTurret.displayRate(render_turret.getTurretRate());
mSpriteTurret.reloadAnimation();
}
public override void Shutdown()
{
base.Shutdown();
if (m_renderNodes != null)
{
CRenderScene scene = CRenderer.Instance.ActiveScene;
foreach (CMeshRenderNode renderNode in m_renderNodes)
{
scene.UnregisterRenderNode(renderNode);
}
m_renderNodes = null;
}
if (m_updateRenderDataScope != null && m_updateRenderDataScope.IsConnected())
{
m_updateRenderDataScope.Disconnect();
m_updateRenderDataScope = null;
}
}
//-------------------------------------------------------------------------
public CSpriteBgNumber(CRenderScene scene, BgColorEnum color, int number)
{
mScene = scene;
float number_layer = mScene.getLayerAlloter().getLayer(_eLevelLayer.TurretScore);
mCSpriteNumber = new CSpriteNumber(mScene, new CPanelDigitFactory(mScene));
mCSpriteNumber.create(number, EbVector3.Zero, 0, CSpriteNumber._eNumberSize.Small2);
mCSpriteNumber.setLayer(number_layer);
mNumberBackgroundCSprite = mScene.getRenderObjectPool().newStillSprite();
mNumberBackgroundCSprite.setLayer(number_layer + mScene.getLayerAlloter().EachFishGap / 100f);
mNumberBackgroundCSprite.setScale(0.65f * number.ToString().Length, 0.8f);
mNumberBackgroundCSprite.playAnimation(getAnimationNameByColor(color));
#if UNITY_EDITOR
mNumberBackgroundCSprite.gameObject.name = "TkSpriteChips_" + getAnimationNameByColor(color);
#endif
}
public void RenderFrame(float deltaTime)
{
if (!Initialized)
{
return;
}
DoFrame(deltaTime);
ActiveScene.UpdateScene(deltaTime);
ActiveScene.RenderScene(m_d3dRenderer.D3DDevice, m_d3dRenderer.D3DDeviceContext);
m_d3dRenderer.PresentActiveWindow();
for (int i = 1; i < m_renderScenes.Count; i++)
{
CRenderScene scene = m_renderScenes[i];
m_d3dRenderer.SetActiveWindow(scene.SceneRenderer);
scene.UpdateScene(deltaTime);
scene.RenderScene(m_d3dRenderer.D3DDevice, m_d3dRenderer.D3DDeviceContext);
m_d3dRenderer.PresentActiveWindow();
}
m_d3dRenderer.EndFrame();
}
public bool TryExecute(Device device, DeviceContext deviceContext, CRenderScene scene)
{
if (!m_sourceAsset.IsLoaded)
{
return(false);
}
for (int i = 0; i < m_sourceAsset.MeshChildren.Count; i++)
{
SMeshChild meshChild = m_sourceAsset.MeshChildren[i];
Transform childTransform = new Transform();
childTransform.SetFromMatrix(in meshChild.relativeTransform);
childTransform.Parent = m_modelTransform;
CMeshRenderNode renderNode = new CMeshRenderNode(m_outer, meshChild.meshAsset, null, childTransform);
if (meshChild.meshAsset.GetAsset().IsLoaded)
{
renderNode.TryCreateResources();
}
scene.RegisterRenderNode(renderNode);
}
return(true);
}
public void GenerateShadowMaps(Device device, DeviceContext deviceContext, CRenderScene renderScene)
{
// Store current render targets. Accourding to the function description we need to release these temporary interfaces
DepthStencilView depthStencilRestore;
RenderTargetView[] renderTargetRestore = deviceContext.OutputMerger.GetRenderTargets(1, out depthStencilRestore);
RawViewportF[] viewPortsRestore = deviceContext.Rasterizer.GetViewports <RawViewportF>();
DepthStencilState depthStenctilStateRestore = deviceContext.OutputMerger.DepthStencilState;
RasterizerState rasterizerRestore = deviceContext.Rasterizer.State;
int shadowMapSlotOffset = 0;
int cubeShadowMapSlotOffset = 0;
// Unbind texture resources
for (int i = CubeShadowMapBaseSlot; i < CubeShadowMapBaseSlot + MaxCubeShadowMaps; i++)
{
deviceContext.PixelShader.SetShaderResource(i, null);
}
for (int i = ShadowMapBaseSlot; i < ShadowMapBaseSlot + MaxShadowMaps; i++)
{
deviceContext.PixelShader.SetShaderResource(i, null);
}
// Generate shadow maps for all active lights
foreach (CDirectionalLight directionalLight in m_directionalLights)
{
if (directionalLight.IsCastingShadow() && !directionalLight.NeedsShadowMapInit())
{
// Init Shadow Map
}
}
foreach (CPositionalLight positionalLight in m_positionalLights)
{
if (positionalLight.IsCastingShadow() && !positionalLight.NeedsShadowMapInit())
{
if (positionalLight.IsShadowMapCube())
{
if (cubeShadowMapSlotOffset < MaxCubeShadowMaps)
{
positionalLight.GenerateShadowMaps(device, deviceContext, renderScene);
positionalLight.ShadowMapRegister = CubeShadowMapBaseSlot + cubeShadowMapSlotOffset;
deviceContext.PixelShader.SetShaderResource(CubeShadowMapBaseSlot + cubeShadowMapSlotOffset, positionalLight.GetShadowMapView());
cubeShadowMapSlotOffset++;
}
}
else
{
if (shadowMapSlotOffset < MaxShadowMaps)
{
positionalLight.GenerateShadowMaps(device, deviceContext, renderScene);
positionalLight.ShadowMapRegister = ShadowMapBaseSlot + shadowMapSlotOffset;
deviceContext.PixelShader.SetShaderResource(ShadowMapBaseSlot + shadowMapSlotOffset, positionalLight.GetShadowMapView());
shadowMapSlotOffset++;
}
}
}
}
m_shadowMapSamplers.SetSamplers(deviceContext);
// Restore previous render targets
deviceContext.OutputMerger.SetRenderTargets(depthStencilRestore, renderTargetRestore);
deviceContext.Rasterizer.SetViewports(viewPortsRestore);
deviceContext.Rasterizer.State = rasterizerRestore;
deviceContext.OutputMerger.DepthStencilState = depthStenctilStateRestore;
//Dispose temporary interfaces
depthStencilRestore?.Dispose();
depthStenctilStateRestore?.Dispose();
rasterizerRestore?.Dispose();
foreach (RenderTargetView renderTargetView in renderTargetRestore)
{
renderTargetView?.Dispose();
}
}
//-------------------------------------------------------------------------
public BgSpriteMgr(CRenderScene scene, CSpriteBackgroundLoader loader)
{
mScene = scene;
mBackgroundLoader = loader;
}
public bool TryExecute(Device device, DeviceContext deviceContext, CRenderScene scene)
{
return(true);
}
//-------------------------------------------------------------------------
public StillSprite newBackgroundStillSprite(string prefab_name, CRenderScene scene)
{
return(mStillSpriteLoader.loadSpriteFromPrefab("Game/Background/" + prefab_name + "Prefab", scene));
}
public override void GenerateShadowMaps(Device device, DeviceContext deviceContext, CRenderScene renderScene)
{
UserDefinedAnnotation annotation = deviceContext.QueryInterface <UserDefinedAnnotation>();
annotation.BeginEvent("SpotLightShadowMap");
deviceContext.Rasterizer.SetViewport(0.0f, 0.0f, CStaticRendererCvars.ShadowMapSize, CStaticRendererCvars.ShadowMapSize);
deviceContext.ClearDepthStencilView(ShadowMapTexture.GetRenderTarget(), DepthStencilClearFlags.Depth, 1.0f, 0);
deviceContext.OutputMerger.SetRenderTargets(ShadowMapTexture.GetRenderTarget());
DepthStencilStateDescription depthStateDesc = new DepthStencilStateDescription()
{
IsDepthEnabled = true,
DepthWriteMask = DepthWriteMask.All,
DepthComparison = Comparison.Less,
IsStencilEnabled = false,
StencilReadMask = 0xFF,
StencilWriteMask = 0xFF,
};
DepthStencilState depthState = new DepthStencilState(device, depthStateDesc);
deviceContext.OutputMerger.SetDepthStencilState(depthState);
SSceneViewInfo viewInfo = new SSceneViewInfo()
{
FitProjectionToScene = false,
Fov = MathUtil.Pi / 2.0f,
ScreenFar = Range,
ScreenNear = 0.1f,
ScreenHeight = CStaticRendererCvars.ShadowMapSize,
ScreenWidth = CStaticRendererCvars.ShadowMapSize,
ScreenLeft = 0.0f,
ScreenTop = 0.0f,
ViewLocation = Transform.WorldPosition,
ViewMatrix = Matrix.Invert(Transform.WorldMatrix)
};
m_projectionMatrix = Matrix.PerspectiveFovLH(viewInfo.Fov, 1.0f, viewInfo.ScreenNear, viewInfo.ScreenFar);
viewInfo.ProjectionMatrix = m_projectionMatrix;
viewInfo.CreateBoundingFrustum();
depthState.Dispose();
renderScene.RenderSceneDepth(device, deviceContext, in viewInfo);
DepthStencilView nullDepthView = null;
deviceContext.OutputMerger.SetRenderTargets(nullDepthView);
annotation.EndEvent();
annotation.Dispose();
}
public bool TryExecute(Device device, DeviceContext deviceContext, CRenderScene scene)
{
m_targetNode.CreateUniqueMaterial();
return(true);
}
//-------------------------------------------------------------------------
public CPanelDigitFactory(CRenderScene scene)
: base(scene)
{
}
public CSpriteNumberFactory(CRenderScene scene)
{
mScene = scene;
}
//-------------------------------------------------------------------------
public CScoreDigitFactory(CRenderScene scene)
: base(scene)
{
}
//-------------------------------------------------------------------------
public CSpriteNumber(CRenderScene render_scene, CSpriteNumberFactory factory)
{
mScene = render_scene;
mFactory = factory;
}
public abstract void GenerateShadowMaps(Device device, DeviceContext deviceContext, CRenderScene renderScene);
//-------------------------------------------------------------------------
public void init(ISpriteFish sprite_fish, CRenderScene scene)
{
base.init(scene);
mISpriteFish = sprite_fish;
}
//-------------------------------------------------------------------------
public LevelScreenShocker(CRenderScene render_scene, CSpriteBackgroundLoader loader)
{
mScene = render_scene;
mBackgroundLoader = loader;
}
//-------------------------------------------------------------------------
public void create(Color color, uint et_player_rpcid, CRenderFish hit_by_bullet_fish, CRenderScene scene, string animation_name)
{
mScene = scene;
mPlayerId = et_player_rpcid;
mCSpriteFishNetGroup = new CSpriteFishNetGroup();
mCSpriteFishNetGroup.create(mScene, color, mPlayerId, animation_name);
mCSpriteFishNetGroup.setTrigger(true);
mCSpriteFishNetGroup.setColor(color);
mCSpriteFishNetGroup.onTriggerEnter += OnTriggerEnter;
addFishList(hit_by_bullet_fish);
}
//-------------------------------------------------------------------------
public LevelSeaStarMgr(CRenderScene render_scene)
{
mScene = render_scene;
}
