public override bool Draw(MyRenderObject renderObject)
{
if (base.Draw(renderObject) == false)
{
return(false);
}
// if (IsControlledByPlayer()) return true;
Matrix worldMatrix = WorldMatrix;
List <MyModelDummy> muzzles = GetMuzzleFlashMatrix();
Vector3 muzzleFlashPosition = MyUtils.GetTransform(muzzles[m_activeMuzzle].Matrix.Translation, ref worldMatrix);
// Draw muzzle flash:
int dt = MyMinerGame.TotalGamePlayTimeInMilliseconds - m_lastTimeShoot;
if (dt <= MyMachineGunConstants.MUZZLE_FLASH_MACHINE_GUN_LIFESPAN && m_muzzleFlashLength > 0)
{
MyParticleEffects.GenerateMuzzleFlash(muzzleFlashPosition, worldMatrix.Forward, m_muzzleFlashRadius, m_muzzleFlashLength);
}
// Draw smoke:
if (m_shotSmoke != null)
{
m_shotSmoke.UserBirthMultiplier = m_smokeToGenerate;
m_shotSmoke.WorldMatrix = Matrix.CreateTranslation(muzzleFlashPosition);
}
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
if (base.Draw(renderObject) == false)
{
return(false);
}
// Draw flare at the end or back of the missile
// Color and range is same as for missile's dynamic light
if (m_light != null)
{
if ((m_initTime - m_elapsedMiliseconds) <= 0)
{
MyTransparentGeometry.AddPointBillboard(MyTransparentMaterialEnum.ReflectorGlareAlphaBlended, m_light.Color,
WorldMatrix.Translation - 1.1f * WorldMatrix.Forward * ModelLod0.BoundingSphere.Radius, m_light.Range * 0.02f, 0);
}
else
{
float delta = m_elapsedMiliseconds / m_initTime;
MyTransparentGeometry.AddPointBillboard(MyTransparentMaterialEnum.ReflectorGlareAlphaBlended, m_light.Color,
WorldMatrix.Translation - WorldMatrix.Forward * ModelLod0.BoundingSphere.Radius, m_light.Range * 0.005f * delta * delta, 0);
}
}
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
base.Draw(renderObject);
// Draw muzzle flash
int deltaTime = MyMinerGame.TotalGamePlayTimeInMilliseconds - m_lastTimeShoot;
if (deltaTime <= MyMachineGunConstants.MUZZLE_FLASH_MACHINE_GUN_LIFESPAN)
{
float FAKE_RADIUS = MyMwcUtils.GetRandomFloat(0.5f, 1.5f);
float FAKE_THICKNESS = MyMwcUtils.GetRandomFloat(FAKE_RADIUS - 0.1f, FAKE_RADIUS);
float FAKE_LENGTH = MyMwcUtils.GetRandomFloat(7, 8);
float FAKE_ANGLE = MyMwcUtils.GetRandomFloat(0, MathHelper.PiOver2);
//float colorComponent = 1;
float colorComponent = 1 - (float)deltaTime / (float)MyMachineGunConstants.MUZZLE_FLASH_MACHINE_GUN_LIFESPAN;
colorComponent = 1 - (float)Math.Pow(colorComponent, 5);
colorComponent *= 1.3f;
//Vector4 color = new Vector4(1.0f, 1.0f, 1.0f, 1);
Vector4 color = new Vector4(colorComponent, colorComponent, colorComponent, 1);
Vector3 muzzleInWorldSpace = m_positionMuzzleInWorldSpace + WorldMatrix.Up * 0.2f;
MyTransparentGeometry.AddLineBillboard(MyTransparentMaterialEnum.MuzzleFlashMachineGunSide, color, muzzleInWorldSpace - WorldMatrix.Forward * 1.0f,
WorldMatrix.Forward, FAKE_LENGTH, FAKE_THICKNESS);
MyTransparentGeometry.AddPointBillboard(MyTransparentMaterialEnum.MuzzleFlashMachineGunFront, color, muzzleInWorldSpace, FAKE_RADIUS, FAKE_ANGLE);
}
return(true);
}
// Draw muzzle flash not matter if in frustum (it's because it's above the frustum)
public override bool Draw(MyRenderObject renderObject)
{
if (base.Draw(renderObject) == false)
{
return(false);
}
m_barrel.Draw();
if (MyMinerGame.IsPaused())
{
return(false);
}
// Draw muzzle flash
int deltaTime = MyMinerGame.TotalGamePlayTimeInMilliseconds - m_lastTimeShoot;
if (deltaTime <= MyMachineGunConstants.MUZZLE_FLASH_MACHINE_GUN_LIFESPAN)
{
MyParticleEffects.GenerateMuzzleFlash(m_positionMuzzleInWorldSpace, WorldMatrix.Forward, m_muzzleFlashRadius, m_muzzleFlashLength, MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD_NEAR);
}
if (m_smokeEffect != null)
{
m_smokeEffect.Near = MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD_NEAR;
}
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
if (base.Draw(renderObject) == false)
{
return(false);
}
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
bool retval = true;
retval = base.Draw(renderObject);
return(retval);
}
public override bool Draw(MyRenderObject renderObject)
{
if (MyGuiScreenGamePlay.IsRenderingInsideEntity(this))
{
return(false);
}
return(base.Draw(renderObject));
}
public override bool Draw(MyRenderObject renderObject = null)
{
if (BuilderActive)
{
MyRender.AddRenderObjectToDraw(RenderObjects[0]);
return(true);
}
return(false);
}
public override bool Draw(MyRenderObject renderObject)
{
bool retVal = base.Draw(renderObject);
foreach (MyEntity child in Children)
{
child.Draw();
}
return(retVal);
}
public override bool Draw(MyRenderObject renderObject)
{
if (MyFakes.STRANGE_PARTICLES_WHEN_DUST_ON_STATIC_ASTEROIDS)
{
MyTransparentGeometry.AddPointBillboard(MyTransparentMaterialEnum.Smoke, new Vector4(0.1f, 0.1f, 0.1f, 1.0f),
GetPosition(), 800, GetPosition().Length());
MyTransparentGeometry.AddPointBillboard(MyTransparentMaterialEnum.Smoke, new Vector4(0.1f, 0.1f, 0.1f, 1.0f),
GetPosition() + (Vector3.Normalize(MyCamera.Position - this.GetPosition()) * 250f), 300, GetPosition().Length() * 2.564f);
}
return(base.Draw(renderObject));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override bool Draw(MyRenderObject renderObject)
{
bool drawOk = base.Draw(renderObject);
if (drawOk)
{
if (m_particleEffect != null)
{
MyParticlesManager.CustomDraw(m_particleEffect);
}
}
return(drawOk);
}
public override bool Draw(MyRenderObject renderObject)
{
base.Draw(renderObject);
/*if (!IsControlledByPlayer())
* {
* //return base.Draw();
* }
* else
* {
* //DrawCrossHair();
* }*/
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
bool draw = base.Draw(renderObject);
if (draw && m_hologramState != HologramState.Deactivated)
{
Vector3 maxScale = MyHologramConstants.FLICKER_MAX_SIZE * Vector3.One;
Vector3 minScale = new Vector3(.01f);
Vector3 clampedScale = Vector3.Clamp(m_scale, minScale, maxScale);
m_hologramShip.SetWorldMatrix(Matrix.CreateScale(clampedScale) * m_hologramBaseMatrix);
m_hologramShip.Draw();
}
return(draw);
}
// Draw muzzle flash not matter if in frustum (it's because it's above the frustum)
public override bool Draw(MyRenderObject renderObject)
{
if (base.Draw(renderObject) == false)
{
return(false);
}
// Draw muzzle flash
int deltaTime = MyMinerGame.TotalGamePlayTimeInMilliseconds - m_lastTimeShoot;
if (deltaTime <= MyMachineGunConstants.MUZZLE_FLASH_MACHINE_GUN_LIFESPAN)
{
MyParticleEffects.GenerateMuzzleFlash(m_positionMuzzleInWorldSpace + WorldMatrix.Forward, WorldMatrix.Forward, 0.4f, 0.7f);
}
return(true);
}
public void RenderForLight(Matrix lightViewProjection, ref BoundingBox lightBoundingBox, Texture shadowRenderTarget, Texture shadowDepth, int spotIndex)
{
m_renderElementsForShadows.Clear();
m_castingRenderObjectsUnique.Clear();
m_spotFrustum.Matrix = lightViewProjection;
//MyRender.GetEntitiesFromPrunningStructure(ref lightBoundingBox, m_castingRenderObjects);
MyRender.GetEntitiesFromShadowStructure(ref lightBoundingBox, m_castingRenderObjects);
foreach (MyElement element in m_castingRenderObjects)
{
MyRenderObject renderObject = (MyRenderObject)element;
MyEntity entity = ((MyRenderObject)element).Entity;
if (entity != null)
{
if (entity is MyVoxelMap)
{
// Changed m_castersBox to lightBoundingBox, should work
//(entity as MyVoxelMap).GetRenderElementsForShadowmap(m_renderElementsForShadows, ref lightBoundingBox, m_spotFrustum, MyLodTypeEnum.LOD0, false);
(entity as MyVoxelMap).GetRenderElementsForShadowmap(m_renderElementsForShadows, renderObject.RenderCellCoord.Value, MyLodTypeEnum.LOD0, false);
}
else
{
if (entity.ModelLod0 != null)
{
MyRender.CollectRenderElementsForShadowmap(m_renderElementsForShadows, m_transparentRenderElementsForShadows, entity, entity.ModelLod0);
}
}
}
}
// Set our targets
MyMinerGame.SetRenderTarget(shadowRenderTarget, shadowDepth);
MyMinerGame.Static.GraphicsDevice.Clear(ClearFlags.All, new ColorBGRA(1.0f), 1.0f, 0);
DepthStencilState.Default.Apply();
RasterizerState.CullNone.Apply();
BlendState.Opaque.Apply();
RenderShadowMap(lightViewProjection);
MyRender.TakeScreenshot("ShadowMapSpot", shadowRenderTarget, MyEffectScreenshot.ScreenshotTechniqueEnum.Color);
}
public override bool Draw(MyRenderObject renderObject)
{
if (!base.Draw(renderObject))
{
return(false);
}
if (ModelLod0 != null)
{
ModelLod0.LoadInDraw();
}
if (ModelLod1 != null)
{
ModelLod1.LoadInDraw();
}
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
var s = base.WorldAABB.Size();
if (!MyGuiScreenGamePlay.Static.IsGameActive())
{
Matrix world = Matrix.CreateWorld(WorldMatrix.Translation, WorldMatrix.Forward, WorldMatrix.Up);
Vector4 color = Color.Green.ToVector4();
color.W *= 0.3f;
BoundingBox localBoundingBox = new BoundingBox(-Size / 2f, Size / 2f);
MySimpleObjectDraw.DrawTransparentBox(ref world, ref localBoundingBox, ref color, true, 1);
}
//base.Draw();
if (IsWorking())
{
m_scanningPart.Draw();
}
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
// return base.Draw();
// if (IsOn())
{
Matrix world = WorldMatrix;
Vector4 color = new Vector4(0f, 0f, 1f, 0.5f);
if (EntityDetectorType == MyEntityDetectorType.Sphere)
{
MySimpleObjectDraw.DrawTransparentSphere(ref world, m_radius, ref color, true, 1);
}
else if (EntityDetectorType == MyEntityDetectorType.Box)
{
BoundingBox bBox = new BoundingBox(-m_extent, m_extent);
MySimpleObjectDraw.DrawTransparentBox(ref world, ref bBox, ref color, true, 1);
}
}
return(true);
}
public void RenderForLight(MatrixD lightViewProjection, Matrix lightViewProjectionAtZero, ref Vector3D lightPosition, Texture shadowRenderTarget, Texture shadowDepth, int spotIndex, List <uint> ignoredObjects)
{
m_renderElementsForShadows.Clear();
m_castingRenderObjectsUnique.Clear();
m_spotFrustum.Matrix = lightViewProjection;
//MyRender.GetEntitiesFromPrunningStructure(ref lightBoundingBox, m_castingRenderObjects);
//MyRender.GetEntitiesFromShadowStructure(ref lightBoundingBox, m_castingRenderObjects);
int occludedItemsStats = 0; //always 0 for shadows
MyRender.PrepareEntitiesForDraw(ref m_spotFrustum, lightPosition, (MyOcclusionQueryID)(1), m_castingRenderObjects, null, m_castingCullObjects, m_castingManualCullObjects, null, ref occludedItemsStats);
foreach (MyElement element in m_castingRenderObjects)
{
MyRenderObject renderObject = (MyRenderObject)element;
if (ignoredObjects.Contains(renderObject.ID))
{
continue;
}
renderObject.GetRenderElementsForShadowmap(MyLodTypeEnum.LOD0, m_renderElementsForShadows, null);
}
// Set our targets
MyRender.SetRenderTarget(shadowRenderTarget, shadowDepth);
MyRender.GraphicsDevice.Clear(ClearFlags.All, new ColorBGRA(1.0f), 1.0f, 0);
DepthStencilState.Default.Apply();
RasterizerState.CullNone.Apply();
BlendState.Opaque.Apply();
RenderShadowMap(lightViewProjectionAtZero);
MyRender.TakeScreenshot("ShadowMapSpot", shadowRenderTarget, MyEffectScreenshot.ScreenshotTechniqueEnum.Color);
}
public override bool Draw(MyRenderObject renderObject)
{
bool drawDebug = MyRender.IsModuleEnabled(MyRenderStage.DebugDraw, MyRenderModuleEnum.InfluenceSpheres);
var isEditorOrDebugDraw = MyGuiScreenGamePlay.Static.IsEditorActive() || drawDebug;
if (isEditorOrDebugDraw && MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD0 && !MyEntities.IsTypeHidden(typeof(MyInfluenceSphere)))
{
Matrix worldMatrix = WorldMatrix;
var innerColor = Color.White.ToVector4();
var innerSphere = new BoundingSphere(worldMatrix.Translation, RadiusMin);
MySimpleObjectDraw.DrawTransparentSphere(ref worldMatrix, innerSphere.Radius, ref innerColor, true, 12,
MyTransparentMaterialEnum.ObjectiveDummyFace,
MyTransparentMaterialEnum.ObjectiveDummyLine);
var outerColor = 0.5f * innerColor;
var outerSphere = new BoundingSphere(worldMatrix.Translation, RadiusMax);
MySimpleObjectDraw.DrawTransparentSphere(ref worldMatrix, outerSphere.Radius, ref outerColor, true, 12,
MyTransparentMaterialEnum.ObjectiveDummyFace,
MyTransparentMaterialEnum.ObjectiveDummyLine);
}
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
if (!base.Draw(renderObject))
{
return(false);
}
//if (IsWorking())
/*{
* Matrix world = Matrix.CreateWorld(WorldMatrix.Translation + ModelLod0.BoundingSphere.Center, WorldMatrix.Forward, WorldMatrix.Up);
* MyTransparentMaterialEnum? faceMaterial;
* MyTransparentMaterialEnum? lineMaterial;
* Vector4 color;
* SetTransparentParameters(out color, out faceMaterial, out lineMaterial);
* if (faceMaterial.HasValue)
* {
* BoundingBox localBoundingBox = m_localBoundingBox;
* MySimpleObjectDraw.DrawTransparentBox(ref world, ref localBoundingBox, ref color, true, 1, faceMaterial, lineMaterial);
* }
* }*/
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
if (Render.MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD0)
{
if (IsDummyVisible())
{
base.Draw(renderObject);
Vector4 color;
switch (DummyFlags)
{
case MyDummyPointFlags.NONE: color = new Vector4(0.5f, 0.7f, 0.1f, 0.3f); break;
case MyDummyPointFlags.SAFE_AREA: color = new Vector4(0.2f, 0.3f, 0.22f, 0.1f); break;
case MyDummyPointFlags.DETECTOR: color = new Vector4(0.12f, 0.1f, 0.7f, 0.3f); break;
case MyDummyPointFlags.PARTICLE: color = new Vector4(0.6f, 0.05f, 0.1f, 0.3f); break;
default: color = new Vector4(0.6f, 0.6f, 0.7f, 0.3f); break;
}
if ((DummyFlags & MyDummyPointFlags.COLOR_AREA) != 0)
{
color = Color; // color Color areas with their area color (overriding the default color). I like to write "color".
}
Matrix worldMatrix = WorldMatrix;
if ((int)(DummyFlags & MyDummyPointFlags.TEXTURE_QUAD) > 0)
{
BoundingBox localAABB = LocalAABB;
MySimpleObjectDraw.DrawWireFramedBox(ref worldMatrix, ref localAABB, ref color, 0.01f, 1, LineMaterial);
if (!string.IsNullOrEmpty(Name))
{
//var tex = MinerWars.AppCode.Game.Textures.MyTextureManager.GetTexture<MinerWars.AppCode.Game.Textures.MyTexture2D>(Name);
int i = 0;
foreach (MyTransparentMaterialEnum trEnum in Enum.GetValues(typeof(MyTransparentMaterialEnum)))
{
if (MyTransparentMaterialConstants.MyTransparentMaterialStrings[i] == Name)
{
Vector4 quadColor = Vector4.One;
MyQuad quad;
Vector3 position = GetPosition();
Vector3 zeroPosition = Vector3.Zero;
var texture = MyTransparentGeometry.GetTexture(trEnum);
float ratio = texture.Height / (float)texture.Width;
MyUtils.GenerateQuad(out quad, ref position, WorldAABB.Size().X *ratio, WorldAABB.Size().X, ref worldMatrix);
MyTransparentGeometry.AddQuad(trEnum, ref quad, ref quadColor, ref position);
}
i++;
}
}
}
else
{
if (Type == MyDummyPointType.Box)
{
BoundingBox localAABB = LocalAABB;
MySimpleObjectDraw.DrawTransparentBox(ref worldMatrix, ref localAABB, ref color, true, 1, FaceMaterial, LineMaterial);
}
else
{
BoundingSphere localSphere = new BoundingSphere(worldMatrix.Translation, Radius);
MySimpleObjectDraw.DrawTransparentSphere(ref worldMatrix, localSphere.Radius, ref color, true, 12, FaceMaterial, LineMaterial);
}
}
}
if (ParticleEffect != null && IsVisible() && Enabled)
{
Vector4 particleColor = Color == Vector4.Zero ? Vector4.One : Color;
ParticleEffect.UserColorMultiplier = particleColor;
ParticleEffect.UserScale = UserScale;
UpdateWorldVolume();
MyParticlesManager.CustomDraw(ParticleEffect);
}
}
return(false);
}
public MyCastShadowJob(MyRenderObject entity)
{
m_renderObject = entity;
VisibleFromSun = false;
//m_entity.OnClose += m_entity_OnMarkForClose;
}
// This method overrides parent draw, that expects that phys object has Model. VoxelHandShape doesnt, so we cant call parent's draw.
public override bool Draw(MyRenderObject renderObject = null)
{
DrawShape();
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
// Nothing, visible parts are GunBase and Barrel
return(true);
}
public override bool Draw(MyRenderObject renderObject)
{
return(base.Draw(renderObject));
}
public MyCastShadowJob(MyRenderObject entity)
{
m_renderObject = entity;
VisibleFromSun = false;
//m_entity.OnClose += m_entity_OnMarkForClose;
}
void PrepareCascadesForDraw()
{
if (MyRender.Sun.Direction == Vector3.Zero)
{
return;
}
MyRender.GetRenderProfiler().StartProfilingBlock("UpdateFrustums");
UpdateFrustums();
MyRender.GetRenderProfiler().EndProfilingBlock();
// Set casting shadows geometry
MyRender.GetRenderProfiler().StartProfilingBlock("update entities");
int frustumIndex = 0;
foreach (MyOrthographicCamera lightCamera in m_lightCameras)
{
if (m_skip[frustumIndex])
{
frustumIndex++;
continue;
}
m_renderElementsForShadows.Clear();
m_transparentRenderElementsForShadows.Clear();
m_castingRenderObjectsUnique.Clear();
MyRender.GetRenderProfiler().StartProfilingBlock("OverlapAllBoundingBox");
var castersBox = lightCamera.BoundingBox; //Cannot use unscaled - incorrect result because of different cascade viewport size
var castersFrustum = lightCamera.BoundingFrustum; //Cannot use unscaled - incorrect result because of different cascade viewport size
int occludedItemsStats = 0; //always 0 for shadows
//MyRender.PrepareEntitiesForDraw(ref castersBox, (MyOcclusionQueryID)(frustumIndex + 1), m_castingRenderObjects, m_occlusionQueriesLists[frustumIndex], ref MyPerformanceCounter.PerCameraDrawWrite.ShadowEntitiesOccluded[frustumIndex]);
MyRender.PrepareEntitiesForDraw(ref castersFrustum, lightCamera.Position, (MyOcclusionQueryID)(frustumIndex + 1), m_castingRenderObjects, null, m_castingCullObjects, m_castingManualCullObjects, null, ref occludedItemsStats);
MyRender.GetRenderProfiler().EndProfilingBlock();
MyRender.GetRenderProfiler().StartProfilingBlock("m_castingRenderObjects");
int c = 0;
int skipped = 0;
while (c < m_castingRenderObjects.Count)
{
MyRenderObject renderObject = (MyRenderObject)m_castingRenderObjects[c];
if (RespectCastShadowsFlags)
{
// System.Diagnostics.Debug.Assert(!(entity is MyDummyPoint) && !(entity is AppCode.Game.Entities.WayPoints.MyWayPoint));
if ((renderObject.ShadowCastUpdateInterval > 0) && ((MyRender.RenderCounter % renderObject.ShadowCastUpdateInterval) == 0))
{
renderObject.NeedsResolveCastShadow = true;
//We have to leave last value, because true when not casting shadow make radiation to ship
// renderObject.CastShadow = true;
}
if (renderObject.NeedsResolveCastShadow)
{ //Resolve raycast to sun
if (renderObject.CastShadowJob == null)
{
renderObject.CastShadowJob = new MyCastShadowJob(renderObject);
renderObject.CastShadowTask = ParallelTasks.Parallel.Start(renderObject.CastShadowJob);
}
else
if (renderObject.CastShadowTask.IsComplete)
{
renderObject.CastShadows = renderObject.CastShadowJob.VisibleFromSun;
renderObject.CastShadowTask = new ParallelTasks.Task();
renderObject.CastShadowJob = null;
renderObject.NeedsResolveCastShadow = false;
if (renderObject.CastShadows == false)
{
HiddenResolvedObjects++;
}
}
}
if (!renderObject.NeedsResolveCastShadow && !renderObject.CastShadows)
{
if (renderObject is MyRenderVoxelCell)
{
}
m_castingRenderObjects.RemoveAtFast(c);
skipped++;
continue;
}
}
else
{
renderObject.NeedsResolveCastShadow = true;
}
if (!m_castingRenderObjectsUnique.Contains(renderObject))
{
m_castingRenderObjectsUnique.Add(renderObject);
if (frustumIndex < MyRenderConstants.RenderQualityProfile.ShadowCascadeLODTreshold)
{
renderObject.GetRenderElementsForShadowmap(MyLodTypeEnum.LOD0, m_renderElementsForShadows, m_transparentRenderElementsForShadows);
}
else
{
renderObject.GetRenderElementsForShadowmap(MyLodTypeEnum.LOD1, m_renderElementsForShadows, m_transparentRenderElementsForShadows);
}
}
c++;
}
MyRender.GetRenderProfiler().EndProfilingBlock();
//Sorting VBs to minimize VB switches
m_renderElementsForShadows.Sort(m_shadowElementsComparer);
lightCamera.CastingRenderElements = m_renderElementsForShadows;
MyPerformanceCounter.PerCameraDrawWrite.RenderElementsInShadows += m_renderElementsForShadows.Count;
frustumIndex++;
}
MyRender.GetRenderProfiler().EndProfilingBlock();
}
public override bool Draw(MyRenderObject renderObject)
{
// Nothing, visible parts are GunBase and Barrel
return true;
}
