Beispiel #1
0
        public Effect( Renderer renderer, string filename )
        {
            //if (!File.Exists(filename))
            //    throw new FileNotFoundException(filename);

            if ( renderer == null )
                throw new ArgumentNullException( "renderer",
                    "Can't create an Effect without a valid renderer." );

            string compilationErrors = "";

            try
            {
                effect = Direct3D.Effect.FromFile( renderer.Device, filename, null, null,
                    null, ShaderFlags.None, null, out compilationErrors );

            }
            catch
            {
                Log.Write( "Unable to create effect " + filename + ". The compilation errors were: \n\n" +
                    compilationErrors );
            }

            renderer.AddGraphicsObject( this );
        }
Beispiel #2
0
 /// <summary>
 /// Initializes a new instance of LightNode.
 /// </summary>
 public LightNode( Renderer renderer, SceneGraph sceneGraph, Matrix localTransform,
     float range, float intensity, Color lightColor)
     : base(renderer, sceneGraph)
 {
     Vector2 pos = Vector2.TransformCoordinate( new Vector2(), localTransform );
     light = renderer.RegisterNewLight( range, intensity, pos, lightColor );
 }
Beispiel #3
0
 /// <summary>
 /// Initializes a new instance of GeometryNode.
 /// </summary>
 public GeometryNode( Renderer renderer, SceneGraph sceneGraph, Matrix localTransform,
     IRenderable renderObject, string material)
     : base(renderer, sceneGraph)
 {
     this.localTransform = localTransform;
     this.renderObject = renderObject;
     this.material = material;
 }
Beispiel #4
0
        /// <summary>
        /// Initializes a new instance of Surface.
        /// </summary>
        public Surface( Renderer renderer, string materialName, Size size )
        {
            this.renderer = renderer;
            this.materialName = materialName;
            this.size = size;

            quad = Mesh.Rectangle( renderer, Color.White, size.Width, size.Height );
        }
Beispiel #5
0
        public Cursor( Renderer renderer, string materialName, Size size )
        {
            this.renderer = renderer;

            this.size = size;
            surface = new Surface( renderer, materialName, size );

            mouse = new MouseDevice( null );
        }
Beispiel #6
0
        /// <summary>
        /// Initializes a new instance of Surface.
        /// </summary>
        public Surface( Renderer renderer, string materialName, Size size,
            float textureMapTiling)
        {
            this.renderer = renderer;
            this.materialName = materialName;
            this.size = size;

            quad = Mesh.Rectangle( renderer, Color.Black, size.Width, size.Height, textureMapTiling );
        }
Beispiel #7
0
        public Obstacle( Renderer renderer, bool invisible, string material )
            : base(renderer, EntityType.Obstacle)
        {
            this.invisible = invisible;
            this.material = material;
            this.mesh = obstacleMesh;

            mass = config.GetSetting<float>( "RobotMass" );
            shadows = config.GetSetting<bool>( "Shadows" );
        }
Beispiel #8
0
        /// <summary>
        /// Builds the material using a standard Direct3D material structure and the name of the VisualEffect.
        /// </summary>
        public Material( Renderer renderer, Direct3D.Material material, string visualEffectName )
        {
            if ( renderer == null )
                throw new ArgumentNullException( "renderer",
                    "Cannot create a material with a null renderer reference." );

            this.renderer = renderer;
            d3dMaterial = material;
            this.visualEffectName = visualEffectName;
        }
Beispiel #9
0
        /// <summary>
        /// Initializes a new instance of VisualEffect.
        /// </summary>
        /// <param name="renderer"></param>
        public VisualEffect( Renderer renderer )
        {
            if ( renderer == null )
            {
                Log.Write( "Can't create a VisualEffect with a null Renderer reference." );
                throw new ArgumentNullException( "renderer",
                    "Can't create a VisualEffect with a null Renderer reference." );
            }

            this.renderer = renderer;
        }
Beispiel #10
0
        public Cursor( Renderer renderer, string materialName, Size size,
            float movementScaleFactor)
        {
            this.renderer = renderer;

            this.size = size;
            this.movementScaleFactor = movementScaleFactor;
            surface = new Surface( renderer, materialName, size );

            mouse = new MouseDevice( null );
        }
Beispiel #11
0
        public Game( Renderer renderer )
        {
            this.renderer = renderer;

            physicsTimeStep = config.GetSetting<float>( "PhysicsTimeStep" );

            SetupMusic();

            fsm.AddState( new SplashScreenState( renderer ) );
            fsm.AddState( new MainMenuState( renderer ) );
            fsm.AddState( new DuelState( renderer ) );
            fsm.DefaultStateID = ( int )StateTypes.SplashScreen;
        }
Beispiel #12
0
        /// <summary>
        /// Builds the material using default parameters.
        /// </summary>
        public Material( Renderer renderer )
        {
            if ( renderer == null )
                throw new ArgumentNullException( "renderer",
                    "Cannot create a material with a null renderer reference." );

            this.renderer = renderer;

            d3dMaterial = new Direct3D.Material();
            d3dMaterial.Ambient = DefaultAmbientColor;
            d3dMaterial.Diffuse = DefaultDiffuseColor;
            d3dMaterial.Specular = DefaultSpecularColor;
            d3dMaterial.SpecularSharpness = DefaultShininess;
        }
Beispiel #13
0
        /// <summary>
        /// Creates an effect from a file. If the effect has already been created, the cached version
        /// is returned.
        /// </summary>
        public static Effect CreateEffectFromFile( Renderer renderer, string filename )
        {
            // Search cache first
            foreach ( string cachedFilename in effectCache.Keys )
            {
                if ( StringHelper.CaseInsensitiveCompare( cachedFilename, filename ) )
                    return effectCache[ cachedFilename ] as Effect;
            }

            Effect newEffect = new Effect( renderer, filename );

            effectCache.Add( filename, newEffect );

            return newEffect;
        }
Beispiel #14
0
        public Scene( Renderer renderer )
        {
            this.renderer = renderer;

            camera = new Camera( renderer );

            crosshair = new Cursor( renderer, "crosshair", new Size( 50, 49 ) );

            arenaSize = new Size( config.GetSetting<int>( "ArenaWidth" ), config.GetSetting<int>( "ArenaHeight" ) );

            aimMode = config.GetSetting<string>( "AimMode" );
            cameraMode = config.GetSetting<string>( "CameraMode" );
            shadows = config.GetSetting<bool>( "Shadows" );

            if ( aimMode != "Relative" && aimMode != "Absolute" )
            {
                Log.Write( "Invalid value for setting 'AimMode'. Defaulting to AimMode = 'Absolute'." );
                aimMode = "Absolute";
            }

            if ( cameraMode != "Fixed" && cameraMode != "Floating" )
            {
                Log.Write( "Invalid value for setting 'CameraMode'. Defaulting to CameraMode = 'Floating'." );
                cameraMode = "Floating";
            }

            lavaTexCoordTiling = config.GetSetting<float>( "LavaTexCoordTiling" );

            arenaGround = new Surface( renderer, "arenaGround", arenaSize, 2.0f );
            lava = new Surface( renderer, "lava", new Size( renderer.FullscreenSize.Width, renderer.FullscreenSize.Height ),
                lavaTexCoordTiling );

            playerBot = new Robot( renderer, new PlayerRobotControl( crosshair ), this );
            cpuBot = new Robot( renderer, new CPURobotControl( this ), this );

            statsFont = new Gas.Graphics.Font( renderer, "Arial", 14 );
            statsFont.ShadowColor = Color.Black;

            playerBot.Position = new Vector2( 500.0f, 0.0f );
            cpuBot.Position = new Vector2( -500.0f, 0.0f );

            entityArbiter.AddEntity( playerBot );
            entityArbiter.AddEntity( cpuBot );

            PopulateArenaWithObstacles();
        }
Beispiel #15
0
        public ExplodingProjectile( Renderer renderer, Vector2 startPos, Vector2 direction,
            Vector2 initialVelocity, Scene scene)
            : base(renderer, startPos, direction, initialVelocity)
        {
            lifetime = config.GetSetting<float>( "ExplodingProjectileTimer" );
            clusterSize = config.GetSetting<int>( "ExplodingProjectileClusterSize" );
            projectileDamage = config.GetSetting<float>( "ExplodingProjectileDamage" );
            speed = config.GetSetting<float>( "ExplodingProjectileSpeed" );

            mesh = renderer.CreateCircularMesh(Color.Black, 13.0f, 6 );

            light = renderer.RegisterNewLight( 200.0f, 1.0f, startPos, Color.Red );

            this.velocity = initialVelocity + direction * speed;

            this.scene = scene;
        }
Beispiel #16
0
        /// <summary>
        /// Creates a font. If the font has already been created, the cached version is returned.
        /// </summary>
        public static Font CreateFont( Renderer renderer, string familyName, int height )
        {
            // Search cache first
            foreach ( CachedFont cf in fontCache.Keys )
            {
                if ( StringHelper.CaseInsensitiveCompare( cf.FamilyName, familyName ) &&
                    cf.Height == height )
                    return fontCache[ cf ] as Font;
            }

            Font newFont = new Font( renderer, familyName, height );
            CachedFont cachedFont = new CachedFont();
            cachedFont.FamilyName = familyName;
            cachedFont.Height = height;

            fontCache.Add( cachedFont, newFont );

            return newFont;
        }
Beispiel #17
0
        public Projectile( Renderer renderer, Vector2 startPos, Vector2 direction,
            Vector2 initialVelocity)
            : base(renderer, EntityType.Projectile)
        {
            this.renderer = renderer;
            this.Position = startPos;
            this.direction = direction;
            this.initialVelocity = initialVelocity;

            lifetime = config.GetSetting<float>( "ProjectileLifetime" );
            speed = config.GetSetting<float>( "ProjectileSpeed" );
            projectileDamage = config.GetSetting<float>( "ProjectileDamage" );

            //light = renderer.RegisterNewLight(250.0f, 1.0f, this.Position, Color.Green);

            mesh = Mesh.Circle( renderer, Color.Black, 5.0f, 6 );

            this.velocity = initialVelocity + direction * speed;
        }
Beispiel #18
0
        /// <summary>
        /// Initializes a new instance of SceneGraphNode.
        /// </summary>
        public SceneGraphNode( Renderer renderer, SceneGraph sceneGraph )
        {
            if ( renderer == null )
            {
                Log.Write( "Cannot create a SceneGraphNode with a null Renderer reference." );
                throw new ArgumentNullException( "renderer",
                    "Cannot create a SceneGraphNode with a null Renderer reference." );
            }

            if ( sceneGraph == null )
            {
                Log.Write( "Cannot create a SceneGraphNode with a null SceneGraph reference." );
                throw new ArgumentNullException( "sceneGraph",
                    "Cannot create a SceneGraphNode with a null SceneGraph reference." );
            }

            this.renderer = renderer;
            this.sceneGraph = sceneGraph;
        }
Beispiel #19
0
        /// <summary>
        /// Creates the texture from a file.
        /// </summary>
        /// <param name="renderer">The renderer.</param>
        /// <param name="filename">The name of the texture file to load.</param>
        public Texture( Renderer renderer, string filename )
        {
            if ( renderer == null )
                throw new ArgumentNullException( "renderer",
                    "Unable to create texture without a valid renderer reference." );

            if ( String.IsNullOrEmpty( filename ) )
                throw new ArgumentNullException( "filename",
                    "Unable to create texture without valid filename." );

            this.renderer = renderer;
            texFilename = filename;

            // Try to load the texture
            try
            {
                if ( File.Exists( filename ) == false )
                    throw new FileNotFoundException( filename );

                ImageInformation imageInfo = TextureLoader.ImageInformationFromFile( filename );
                size = new Size( imageInfo.Width, imageInfo.Height );

                if ( size.Width == 0 || size.Height == 0 )
                    throw new InvalidOperationException(
                        "Image size=" + size + " is invalid, unable to create texture." );

                hasAlpha = imageInfo.Format == Format.Dxt5 ||
                    imageInfo.Format == Format.Dxt3 ||
                    imageInfo.Format.ToString().StartsWith( "A" );

                d3dTexture = TextureLoader.FromFile( this.renderer.Device, filename );

                loaded = true;

                renderer.AddGraphicsObject( this );
            }
            catch ( Exception ex )
            {
                loaded = false;
                Log.Write( "Failed to load texture " + filename +
                    ", will use empty texture! Error: " + ex.ToString() );
            }
        }
Beispiel #20
0
        public Robot( Renderer renderer, Scene scene )
            : base(renderer, EntityType.Robot)
        {
            mesh = Mesh.Circle( renderer, Color.White, 60, 24 );
            turret = new Surface( renderer, "turret", new Size( 20, 75 ) );
            this.scene = scene;

            frictionalCoefficient = config.GetSetting<float>( "FrictionalCoefficient" );
            mass = config.GetSetting<float>( "RobotMass" );
            coefficientOfRestitution = config.GetSetting<float>( "CoefficientOfRestitution" );

            projectileFireInterval = config.GetSetting<float>( "ProjectileFireInterval" );
            timeSinceLastProjFire = projectileFireInterval;

            explodingProjFireInterval = config.GetSetting<float>( "ExplodingProjectileFireInterval" );
            timeSinceLastExplodingProjFire = explodingProjFireInterval;

            health = config.GetSetting<int>( "RobotStartHealth" );
        }
Beispiel #21
0
        public Light( Renderer renderer, float range, float intensity )
        {
            if ( renderer == null )
            {
                Log.Write( "'renderer' is null." );
                throw new ArgumentNullException( "renderer", "Can't create a Light with a null " +
                    "renderer reference." );
            }

            if ( intensity < 0.0f || intensity > 1.0f )
            {
                Log.Write( "'intensity' is out of range." );
                throw new ArgumentOutOfRangeException( "intensity", intensity,
                    "'intensity' is outside of the range [0,1]." );
            }

            this.renderer = renderer;
            this.range = range;
            this.intensity = intensity;
        }
Beispiel #22
0
        /// <summary>
        /// Initializes the BloomPostProcessor.
        /// </summary>
        public BloomPostProcessor( Renderer renderer )
        {
            if ( renderer == null )
                throw new ArgumentNullException( "renderer", "Can't create the BloomPostProcessor with a "
                    + "null Renderer reference." );

            this.renderer = renderer;

            brightPassTex = new Texture( renderer, renderer.FullscreenSize.Width / 2,
                renderer.FullscreenSize.Height / 2, true );
            blurHorizontalTex = new Texture( renderer, renderer.FullscreenSize.Width / 2,
                renderer.FullscreenSize.Height / 2, true );
            blurVerticalTex = new Texture( renderer, renderer.FullscreenSize.Width / 2,
                renderer.FullscreenSize.Height / 2, true );
            finalBloomImage = new Texture( renderer, renderer.FullscreenSize.Width,
                renderer.FullscreenSize.Height, true );

            fullscreenQuad = Mesh.Rectangle( renderer, Color.Black, renderer.FullscreenSize.Width,
                renderer.FullscreenSize.Height );

            bloomEffect = GlobalResourceCache.CreateEffectFromFile( renderer,
                @".\\FXFiles\\Bloom.fx" );
        }
Beispiel #23
0
        /// <summary>
        /// Constructs the font object using the desired font family. If the desired family
        /// is not supported, the fallback family defined in the Settings file is used.
        /// </summary>
        public Font( Renderer renderer, string familyName, int height )
        {
            this.renderer = renderer;
            this.familyName = familyName;
            this.height = height + 5;

            // Attempt to create the Windows font object
            try
            {
                windowsFont = new System.Drawing.Font( familyName, this.height,
                    System.Drawing.FontStyle.Regular );
            }
            catch
            {
                // Attempt to create the font using the "fallback" font family
                // defined in the Settings file
                Log.Write( "The desired font family was not available." );
            }

            d3dFont = new Direct3D.Font( renderer.Device, windowsFont );
            textSprite = new Direct3D.Sprite( renderer.Device );

            renderer.AddGraphicsObject( this );
        }
Beispiel #24
0
 /// <summary>
 /// Builds a circular mesh centered around the origin.
 /// </summary>
 public static Mesh Circle( Renderer renderer, Color color, float radius,
     int numSubdivisions)
 {
     return Mesh.Circle( renderer, color, radius, numSubdivisions, 1.0f );
 }
Beispiel #25
0
 public SplashScreenState( Renderer renderer )
 {
     this.renderer = renderer;
     type = ( int )StateTypes.SplashScreen;
     splashScreen = new Surface( renderer, "splashScreen", renderer.FullscreenSize );
 }
Beispiel #26
0
            public MainMenuState( Renderer renderer )
            {
                type = ( int )StateTypes.MainMenu;
                this.renderer = renderer;

                background = new Surface( renderer, "mainMenuBg", renderer.FullscreenSize );

                cursor = new Cursor( renderer, "cursor", new Size( 50, 50 ) );

                mainMenu = new Menu( renderer, new Vector2( 0, -30 ), 80.0f, config.GetSetting<string>( "MainMenuFont" ),
                    cursor, "buttonPressed", "buttonUnpressed", new Size( 200, 50 ) );

                mainMenu.AddButton( "Duel", "Duel" );
                mainMenu.AddButton( "Survival", "Survival" );
                mainMenu.AddButton( "Quit", "Quit" );

                mainMenu.GetButton( "Duel" ).Pressed += new EventHandler( OnDuelPressed );
                mainMenu.GetButton( "Survival" ).Pressed += new EventHandler( OnSurvivalPressed );
                mainMenu.GetButton( "Quit" ).Pressed += new EventHandler( OnQuitButtonPressed );
            }
Beispiel #27
0
            public DuelState( Renderer renderer )
            {
                this.renderer = renderer;
                type = ( int )StateTypes.DuelState;

                ShadowManager.Initialize( renderer );

                scene = new Scene( renderer );
            }
Beispiel #28
0
        /// <summary>
        /// Builds a rectangular mesh, centered around the origin.
        /// </summary>
        public static Mesh Rectangle( Renderer renderer, Color color, float width, float height,
            float textureMapTiling)
        {
            Mesh rectMesh = new Mesh( renderer, 4, 2 );

            rectMesh.AddVertex( 0, new Vector3( -width / 2, height / 2, 1.0f ), color,
                new Vector2( 0.0f, 0.0f ) );
            rectMesh.AddVertex( 1, new Vector3( width / 2, height / 2, 1.0f ), color,
                new Vector2( textureMapTiling, 0.0f ) );
            rectMesh.AddVertex( 2, new Vector3( width / 2, -height / 2, 1.0f ), color,
                new Vector2( textureMapTiling, textureMapTiling ) );
            rectMesh.AddVertex( 3, new Vector3( -width / 2, -height / 2, 1.0f ), color,
                new Vector2( 0.0f, textureMapTiling ) );

            rectMesh.AddTriangle( 0, 0, 1, 2 );
            rectMesh.AddTriangle( 1, 0, 2, 3 );

            return rectMesh;
        }
Beispiel #29
0
 /// <summary>
 /// Builds a rectangular mesh, centered around the origin.
 /// </summary>
 public static Mesh Rectangle( Renderer renderer, Color color, float width, float height )
 {
     return Mesh.Rectangle( renderer, color, width, height, 1.0f );
 }
Beispiel #30
0
        /// <summary>
        /// Builds a circular mesh centered around the origin.
        /// </summary>
        public static Mesh Circle( Renderer renderer, Color color, float radius,
            int numSubdivisions, float textureMapTiling)
        {
            Mesh circleMesh = new Mesh( renderer, numSubdivisions, numSubdivisions - 2 );

            float angleStep = ( 2 * ( float )Math.PI ) / numSubdivisions;
            for ( int i = 0; i < numSubdivisions; ++i )
            {
                Vector2 texCoords = textureMapTiling * ( new Vector2(
                    ( float )Math.Cos( angleStep * i ) / 2.0f + 0.5f,
                    1.0f - ( ( float )Math.Sin( angleStep * i ) / 2.0f + 0.5f ) ) );

                circleMesh.AddVertex( i, new Vector3( radius * ( float )Math.Cos( angleStep * i ),
                    radius * ( float )Math.Sin( angleStep * i ), 1.0f ), color, texCoords );
            }

            for ( int i = 2, count = 0; i < numSubdivisions - 1; ++i, ++count )
            {
                circleMesh.AddTriangle( count, 0, i, i - 1 );
            }

            circleMesh.AddTriangle( numSubdivisions - 3, 0, numSubdivisions - 2, numSubdivisions - 1 );

            return circleMesh;
        }