ArsLudica.org Forum

Effettua l'accesso o una nuova registrazione.

Inserisci il nome utente, la password e la durata della sessione.
Ricerca avanzata  

News:

Autore Topic: Sviluppo XNA  (Letto 6048 volte)

Ziggybee

  • Administrator
  • Hero Member
  • *****
  • Offline Offline
  • Post: 8.383
  • Gamer Extraordinaire
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #30 il: Febbraio 15, 2009, 23:27:54 »

Ma cos'è sta roba??
        protected override void ProcessVertexChannel(GeometryContent geometry,
            int vertexChannelIndex, ContentProcessorContext context)
        {
            String vertexChannelName =
                geometry.Vertices.Channels[vertexChannelIndex].Name;

            // if this vertex channel has an acceptable names, process it as normal.
            if (acceptableVertexChannelNames.Contains(vertexChannelName))
            {
                base.ProcessVertexChannel(geometry, vertexChannelIndex, context);
            }
            // otherwise, remove it from the vertex channels; it's just extra data
            // we don't need.
            else
            {
                geometry.Vertices.Channels.Remove(vertexChannelName);
            }
        }

Cosa fa questo codice? Perchè serve? E perchè serve nel progetto del gioco?

Questa roba deve stare fuori! Cos'è questo mischiare creazione di asset col gioco?

E' proprio per evitare di avere decine di developer ognuno con la sua parrocchia, limitare i costi e snellire i tempi di gestione di tutto il processo di sviluppo.

Comunque la gestione dei processor non riguarda il programmatore grafico.

Infatti qui in casa mia in questo momento siamo in dieci programmatori che vorrebbero fare un giochino, ognuno con la sua specializzazione.

Boh, cmq renditi conto che stai criticando qualcosa che va ben oltre il semplice "carico un modello per fare normal mapping".
Connesso
Matteo Anelli

Vazkor: "Altro che Apple TV"

Monopoli

  • Hero Member
  • *****
  • Offline Offline
  • Post: 4.296
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #31 il: Febbraio 15, 2009, 23:32:47 »

Sto criticando qualcosa che per fare una banalità richiede paginate di codice.

Probabilmente se mi chiedessi di farlo in C++ da zero con DX, il listato sarebbe più breve.

Sto criticando qualcosa che è esattamente come Renderware: una merda pazzesca, ma bisogna usarlo per forza, perchè è così punto e stop.
Gli concedo ancora esattamente 8 ore del mio tempo, solamente perchè a te piace tanto e quindi qualcosa di buono ci deve essere per forza.
Connesso
Il mio blog agghiacciante
http://monopoliano.blogspot.com
E' Uscito! Compra qui: http://itunes.apple.com/us/album/crystal/id461134607

"Monopoli hai la voce da frocio ma sei un figo sull'Arsludicast."

Ziggybee

  • Administrator
  • Hero Member
  • *****
  • Offline Offline
  • Post: 8.383
  • Gamer Extraordinaire
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #32 il: Febbraio 15, 2009, 23:38:54 »

Benvenuto nel ventesimo secolo, le annotazioni, le lambda operations e l'AOP sono diventate la norma nei linguaggi ad oggetti moderni.

L'attributo serve per definire i parametri necessari al Visual Studio, visto che il processor è un plug in di Visual Studio e MSBuild.

In pratica l'attributo stà la per dire a VS (o ad un'altro software) che il tuo binario ha dei metodi che possono essere agganciati per fare qualcosa di specifico. E' utile, come nel caso dei processor, per sviluppare plugin per gli IDE o le applicazioni, dove i metodi sono in grado di autodefinirsi e descriversi per essere integrati in altri ambienti.

Ad esempio se hai una struttura dati di un salvataggio e vuoi poterla serializzare in XML ma per motivi tuoi hai necessità di cambiare l'associazione di alcune proprietù dell'oggetto in elementi piuttosto che attributi dell'XML con due annotazioni lo fai, senza dover riscrivere la classe o gestire la serializzazione manualmente. E' il serializzatore che esplora gli oggetti a sapere come regolarsi quando incontra un'annotazione.

La cosa che non vedi mai negli esempio, ma che sarebbe la norma è che gli attributi non dovrebbero mai essere nel Main code del tuo oggetto ma in una classe parziale (un'aspetto, se preferisci) scritta apposta per essere configurabile indipendentemente dal resto: in questo modo hai dei repository per intervenire sui metadati degli oggetti, senza necessariamente intervenire sull'implementazione.
Connesso
Matteo Anelli

Vazkor: "Altro che Apple TV"

Monopoli

  • Hero Member
  • *****
  • Offline Offline
  • Post: 4.296
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #33 il: Febbraio 15, 2009, 23:40:47 »

Capiamoci bene: questo listato

Codice: [Seleziona]
#region File Description
//-----------------------------------------------------------------------------
// NormalMappingEffect.cs
//
// Microsoft XNA Community Game Platform
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#endregion

#region Using Statements
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
#endregion

namespace NormalMappingEffect
{
    /// <summary>
    /// Sample shows how to render a model using a custom effect.
    /// </summary>
    public class NormalMappingEffectGame : Microsoft.Xna.Framework.Game
    {
        #region Fields

        GraphicsDeviceManager graphics;

        KeyboardState lastKeyboardState = new KeyboardState();
        GamePadState lastGamePadState = new GamePadState();
        KeyboardState currentKeyboardState = new KeyboardState();
        GamePadState currentGamePadState = new GamePadState();

        Model model;

        // the next 4 fields are inputs to the normal mapping effect, and will be set
        // at load time.  change these to change the light properties to modify
        // the appearance of the model.
        Vector4 lightColor = new Vector4(1, 1, 1, 1);
        Vector4 ambientLightColor = new Vector4(.2f, .2f, .2f, 1);
        float shininess = .3f;
        float specularPower = 4.0f;
        
        // the sample arc ball camera values
        float cameraArc = 0;
        float cameraRotation = 45;
        float cameraDistance = 1500;

        // the light rotates around the origin using these 3 constants.  the light
        // position is set in the draw function.
        const float LightHeight = 600;
        const float LightRotationRadius = 800;
        const float LightRotationSpeed = .5f;
        bool rotateLight = true;
        float lightRotation;

        #endregion

        #region Initialization


        public NormalMappingEffectGame()
        {
            Content.RootDirectory = "Content";

            graphics = new GraphicsDeviceManager(this);
            
            graphics.PreferredBackBufferWidth = 853;
            graphics.PreferredBackBufferHeight = 480;

            graphics.MinimumPixelShaderProfile = ShaderProfile.PS_2_0;
        }


        /// <summary>
        /// Load your graphics content.
        /// </summary>
        protected override void LoadContent()
        {
            model = Content.Load<Model>("lizard");
            foreach (ModelMesh mesh in model.Meshes)
            {
                foreach (Effect effect in mesh.Effects)
                {
                    effect.Parameters["LightColor"].SetValue(lightColor);
                    effect.Parameters["AmbientLightColor"].SetValue
                        (ambientLightColor);

                    effect.Parameters["Shininess"].SetValue(shininess);
                    effect.Parameters["SpecularPower"].SetValue(specularPower);
                }
            }
        }


        #endregion

        #region Update and Draw


        /// <summary>
        /// Allows the game to run logic.
        /// </summary>
        protected override void Update(GameTime gameTime)
        {
            HandleInput();

            UpdateCamera(gameTime);

            // Turn on the rotating light
            if ((currentGamePadState.Buttons.A == ButtonState.Pressed &&
                lastGamePadState.Buttons.A != ButtonState.Pressed) ||
                (currentKeyboardState.IsKeyUp(Keys.Space) &&
                lastKeyboardState.IsKeyDown(Keys.Space)))
            {
                rotateLight = !rotateLight;
            }

            base.Update(gameTime);
        }


        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice device = graphics.GraphicsDevice;

            device.Clear(Color.CornflowerBlue);


            float aspectRatio = (float)device.Viewport.Width /
                                (float)device.Viewport.Height;

            // Compute camera matrices.
            Matrix unrotatedView = Matrix.CreateLookAt(
                new Vector3(0, 0, -cameraDistance), Vector3.Zero, Vector3.Up);

            Matrix view = Matrix.CreateRotationY(MathHelper.ToRadians(cameraRotation)) *
                          Matrix.CreateRotationX(MathHelper.ToRadians(cameraArc)) *
                          unrotatedView;
                          

            Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
                                                                    aspectRatio,
                                                                    1,
                                                                    10000);

            if (rotateLight)
            {
                lightRotation +=
                    (float)gameTime.ElapsedRealTime.TotalSeconds * LightRotationSpeed;
            }

            Matrix lightRotationMatrix = Matrix.CreateRotationY(lightRotation);
            Vector3 lightPosition = new Vector3(LightRotationRadius, LightHeight, 0);
            lightPosition = Vector3.Transform(lightPosition, lightRotationMatrix);

            // Draw the model.
            Matrix[] transforms = new Matrix[model.Bones.Count];

            model.CopyAbsoluteBoneTransformsTo(transforms);

            foreach (ModelMesh mesh in model.Meshes)
            {
                foreach (Effect effect in mesh.Effects)
                {
                    Matrix world = transforms[mesh.ParentBone.Index];

                    effect.Parameters["World"].SetValue(world);
                    effect.Parameters["View"].SetValue(view);
                    effect.Parameters["Projection"].SetValue(projection);
                    effect.Parameters["LightPosition"].SetValue(lightPosition);
                }

                mesh.Draw();
            }

            base.Draw(gameTime);
        }


        #endregion

        #region Handle Input


        /// <summary>
        /// Handles input for quitting the game.
        /// </summary>
        private void HandleInput()
        {
            lastKeyboardState = currentKeyboardState;
            lastGamePadState = currentGamePadState;

            currentKeyboardState = Keyboard.GetState();
            currentGamePadState = GamePad.GetState(PlayerIndex.One);

            // Check for exit.
            if (currentKeyboardState.IsKeyDown(Keys.Escape) ||
                currentGamePadState.Buttons.Back == ButtonState.Pressed)
            {
                Exit();
            }
        }


        /// <summary>
        /// Handles camera input.
        /// </summary>
        private void UpdateCamera(GameTime gameTime)
        {
            float time = (float)gameTime.ElapsedGameTime.TotalMilliseconds;

            // Check for input to rotate the camera up and down around the model.
            if (currentKeyboardState.IsKeyDown(Keys.Up) ||
                currentKeyboardState.IsKeyDown(Keys.W))
            {
                cameraArc += time * 0.1f;
            }

            if (currentKeyboardState.IsKeyDown(Keys.Down) ||
                currentKeyboardState.IsKeyDown(Keys.S))
            {
                cameraArc -= time * 0.1f;
            }

            cameraArc += currentGamePadState.ThumbSticks.Right.Y * time * 0.25f;

            // Limit the arc movement.
            if (cameraArc > 90.0f)
                cameraArc = 90.0f;
            else if (cameraArc < -90.0f)
                cameraArc = -90.0f;

            // Check for input to rotate the camera around the model.
            if (currentKeyboardState.IsKeyDown(Keys.Right) ||
                currentKeyboardState.IsKeyDown(Keys.D))
            {
                cameraRotation += time * 0.1f;
            }

            if (currentKeyboardState.IsKeyDown(Keys.Left) ||
                currentKeyboardState.IsKeyDown(Keys.A))
            {
                cameraRotation -= time * 0.1f;
            }

            cameraRotation += currentGamePadState.ThumbSticks.Right.X * time * 0.25f;

            // Check for input to zoom camera in and out.
            if (currentKeyboardState.IsKeyDown(Keys.Z))
                cameraDistance += time * 0.5f;

            if (currentKeyboardState.IsKeyDown(Keys.X))
                cameraDistance -= time * 0.5f;

            cameraDistance += currentGamePadState.Triggers.Left * time;
            cameraDistance -= currentGamePadState.Triggers.Right * time;

            // Limit the camera distance.
            if (cameraDistance > 5000.0f)
                cameraDistance = 5000.0f;
            else if (cameraDistance < 350.0f)
                cameraDistance = 350.0f;

            if (currentGamePadState.Buttons.RightStick == ButtonState.Pressed ||
                currentKeyboardState.IsKeyDown(Keys.R))
            {
                cameraArc = 0;
                cameraRotation = 45;
                cameraDistance = 1500;
            }
        }


        #endregion
    }


    #region Entry Point

    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    static class Program
    {
        static void Main()
        {
            using (NormalMappingEffectGame game = new NormalMappingEffectGame())
            {
                game.Run();
            }
        }
    }

    #endregion
}

E' buono. E' quello che mi aspetto da un framework.

Ma.

Il materiale "normal mapping" chi gliel'ha assegnato alla lucertola? E i multimaterial? Ovviamente gestiti dal loop sui materiali. Chi viene prima? Come si chiamano? Come setto le trasformazioni ad ognuno? Lo posso fare?
Tutto l'assegnamento è fatto in quel codice inguardabile presente nell'altro progetto? Così sembra. Chi lo chiama? Esiste da qualche parte un binding? Perchè è tutto nascosto?

Quella lucertola da dove arriva? Da max? Da Maya? chi ha fatto quell'fbx? Che materiale gli ha assegnato?

Non potevano fare un exporter per il loro formato? Con dentro le mesh, le texture fuori ed i materiali fuori? Perchè usare formati vecchi e brutti per poi farli convertire da visual studio in qualcosa di ignoto?
Connesso
Il mio blog agghiacciante
http://monopoliano.blogspot.com
E' Uscito! Compra qui: http://itunes.apple.com/us/album/crystal/id461134607

"Monopoli hai la voce da frocio ma sei un figo sull'Arsludicast."

Ziggybee

  • Administrator
  • Hero Member
  • *****
  • Offline Offline
  • Post: 8.383
  • Gamer Extraordinaire
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #34 il: Febbraio 15, 2009, 23:44:56 »

Sto criticando qualcosa che per fare una banalità richiede paginate di codice.

Probabilmente se mi chiedessi di farlo in C++ da zero con DX, il listato sarebbe più breve.

Sto criticando qualcosa che è esattamente come Renderware: una merda pazzesca, ma bisogna usarlo per forza, perchè è così punto e stop.
Gli concedo ancora esattamente 8 ore del mio tempo, solamente perchè a te piace tanto e quindi qualcosa di buono ci deve essere per forza.

Io mi ci trovo bene, ma devi pure considerare che ho familiarità con C# e tutte le caratteristiche della programmazione ad oggetti di nuova generazione, che con .NET 3 hanno dato filo da torcere ad un sacco di gente (io ancora non faccio mio il lambda code ma sto imparando :P).

E non sono uno che programma con la scopa al culo, in .NET dichiaro proprietà solo se hanno una ragione di esistere, visto che a livello di integrazione col resto del codice non c'è differenza tra una proprietà get/set o un membro pubblico.

Se leggi la mia recensione che passò su Slashdot di XNA 1.0 anche io dicevo che era una deludente merda pazzesca.
Connesso
Matteo Anelli

Vazkor: "Altro che Apple TV"

Monopoli

  • Hero Member
  • *****
  • Offline Offline
  • Post: 4.296
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #35 il: Febbraio 15, 2009, 23:57:26 »

Lo che ti ci trovi bene: non fai che parlarne bene :D

Ma io qui non vedo un ambiente professionale. Vedo un ambiente per giocare. Che se voi farci qualcosa di serio puoi usare sì e no l'1% delle sue funzionalità e riscriverti tutto il resto.

Ah: le funzioni lambda ci sono da anni in Boost, in C++ :D Così come un po' tutto quello che c'è di nuovi nei nuovi linguaggi.
Semplicemente nei nuovi linguaggi è tutto più simile alla teoria, quindi dovrebbe essere tutto più facile.

In Python E' tutto più facile. Qui mi sembra che è tutto bello finchè non ci devi lavorare :D
Connesso
Il mio blog agghiacciante
http://monopoliano.blogspot.com
E' Uscito! Compra qui: http://itunes.apple.com/us/album/crystal/id461134607

"Monopoli hai la voce da frocio ma sei un figo sull'Arsludicast."

Ziggybee

  • Administrator
  • Hero Member
  • *****
  • Offline Offline
  • Post: 8.383
  • Gamer Extraordinaire
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #36 il: Febbraio 15, 2009, 23:59:17 »

E' buono. E' quello che mi aspetto da un framework.

Ma.

Il materiale "normal mapping" chi gliel'ha assegnato alla lucertola? E i multimaterial? Ovviamente gestiti dal loop sui materiali. Chi viene prima? Come si chiamano? Come setto le trasformazioni ad ognuno? Lo posso fare?
Si leggiti i manuali, lo puoi fare. Solo che, purtroppo, essendo qualcosa di totalmente nuovo parti completamente svantaggiato, ci sono passato pure io, che, tra parentesi, ho sempre preferito le API DX in C a quelle in C++.

Citazione
Tutto l'assegnamento è fatto in quel codice inguardabile presente nell'altro progetto? Così sembra. Chi lo chiama? Esiste da qualche parte un binding? Perchè è tutto nascosto?
Lo chiama Visual Studio quando compili (leggiti il manuale). Quando lanci il build, XNA prende i content sviluppati dai grafici e tramite il collante degli importer e dei processor crea il suo formato proprietario intermedio, ottimizzato a seconda della piattaforma, a partire a formati brutti e vecchi perché spesso sono quelli che la gente sa usare. Per esempio, alcuni processor sono parametrizzabili.

Tu dirai perché? Perché così è possibile cambiare il texture format che utilizzi senza dover toccare minimanente il codice, oppure sostituire il modo in cui la geometria o i lod sono creati senza dover rifare i modelli o mettere mano al codice di rendering.

Una cosa che mi hai fatto notare tu è proprio quella delle texture, un flag per lasciare al codice la gestione delle texture non sarebbe stato male.

Citazione
Quella lucertola da dove arriva? Da max? Da Maya? chi ha fatto quell'fbx? Che materiale gli ha assegnato?
E' fatto così perché a chi scrive il codice non deve interessare da dove arriva la lucertola o di come sono stati gestiti i materiali sull'editor 3D.

Citazione
Non potevano fare un exporter per il loro formato? Con dentro le mesh, le texture fuori ed i materiali fuori? Perchè usare formati vecchi e brutti per poi farli convertire da visual studio in qualcosa di ignoto?
E' quello che stavi criticando tu! E' il formato proprietario che però non lo devi integrare DENTRO i tool di grafica ma solo dentro la pipeline di build management del gioco. Così non hai bisogno di skill specialistiche.

Ad esempio nel mio caso i punti da cui i modelli sparano sono dei quad con una normale, messi nell'editor, con dei nomi appositi.

Piuttosto che farmi un plugin per Blender (non lo so fare) mi sono fatto un importer che mi tira fuori quei quad dalle geometrie (che arrivano pulite al processor) e mi genera un piccolo XML con le serializzazioni delle istanza dei BulletGenerator che mi servivano per quel modello comprensive di tutte le matrici di trasformazione necessarie.

L'XML è incompleto: perché tranne le informazioni geometriche, mancano i parametri sul tipo di sparo, che posso mettere io a mano, visto che il rognoso è parametrizzare le matrici di trasformazione rispetto al centro del modello e tutto il resto è tuning di game design.

L'XML gerato non c'è nemmeno bisogno che lo processo con un Processor, posso deserializzarlo passando direttamente dal ContentManager di XNA. Una volta sicuro, potrò rendere tutto serializzato in binario, così anche l'overhead del parsing non ci sarà, a costo zero, switchando un parametrino.
Connesso
Matteo Anelli

Vazkor: "Altro che Apple TV"

Monopoli

  • Hero Member
  • *****
  • Offline Offline
  • Post: 4.296
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #37 il: Febbraio 16, 2009, 00:07:55 »

Ok, dove stanno questi magici manuali? :D

Ah:

Citazione
E' fatto così perché a chi scrive il codice non deve interessare da dove arriva la lucertola o di come sono stati gestiti i materiali sull'editor 3D.

MAGARI no, ma almeno mi piacerebbe sapere che materiali sono.
Connesso
Il mio blog agghiacciante
http://monopoliano.blogspot.com
E' Uscito! Compra qui: http://itunes.apple.com/us/album/crystal/id461134607

"Monopoli hai la voce da frocio ma sei un figo sull'Arsludicast."

Ziggybee

  • Administrator
  • Hero Member
  • *****
  • Offline Offline
  • Post: 8.383
  • Gamer Extraordinaire
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #38 il: Febbraio 16, 2009, 00:09:59 »

Ma io qui non vedo un ambiente professionale. Vedo un ambiente per giocare. Che se voi farci qualcosa di serio puoi usare sì e no l'1% delle sue funzionalità e riscriverti tutto il resto.

Tieniti forte, XNA non sarà mai un middleware. E' una libreria di base, è ovvio che per fare cose avanzate devi scriverti i componenti, il favore che ti fà è renderli più vicini al tuo ambiente di sviluppo e più lontani dai tool accessori, così ti puoi creare delle librerie di componenti a lungo termine. In realtà Microsoft pare contare molto sul successo riscosso per farle diventare le API ufficiali per programmare nelle varie implementazioni di DX future e spingere di più su .NET nel ludico...

Per il resto mi è comprensibile il disagio. Cmq prenditi un po' di tempo per leggerti almeno la parte che introduce bene l'architettura e le pipeline di Update e Rendering, ci sono passato pure io e devo dire che nonostante molte tecniche sono piuttosto comuni negli scenegraph basati su compilazione JIT c'era troppa nuova carne al fuoco per farci un'hands-on da subito.
Connesso
Matteo Anelli

Vazkor: "Altro che Apple TV"

Monopoli

  • Hero Member
  • *****
  • Offline Offline
  • Post: 4.296
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #39 il: Febbraio 16, 2009, 00:13:12 »

Ma io qui non vedo un ambiente professionale. Vedo un ambiente per giocare. Che se voi farci qualcosa di serio puoi usare sì e no l'1% delle sue funzionalità e riscriverti tutto il resto.

Tieniti forte, XNA non sarà mai un middleware.

Peccato che sia presentato come un supremo framework nel quale devi fare poco o niente e spunta il gioco :D A me sembra una versione di directx più semplice ma in fondo meno usabile.

Se voglio fare qualcosa con DirectX, lo faccio con directX, non con questa cosa qui.

Ah: dove sono sti magici manuali? :D
Connesso
Il mio blog agghiacciante
http://monopoliano.blogspot.com
E' Uscito! Compra qui: http://itunes.apple.com/us/album/crystal/id461134607

"Monopoli hai la voce da frocio ma sei un figo sull'Arsludicast."

Ziggybee

  • Administrator
  • Hero Member
  • *****
  • Offline Offline
  • Post: 8.383
  • Gamer Extraordinaire
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #40 il: Febbraio 16, 2009, 00:15:13 »

Ok, dove stanno questi magici manuali? :D

Dentro l'help del Visual Studio, c'è un libro nuovo che si chiama, neanche troppo metafisicamente, XNA Game Studio 3.0. Neanche a farlo apposta, la programming guide, dopo un'introduzione genrica inizia proprio con.... LA CONTENT PIPELINE!!!!!!  ;D

Che comunque ha mandato TUTTI al manicomio.

Ritienito fortunato (per ora) a non dovere fare interfacce con WPF e XAML, se vedi come integrare Expression Design, Espression Blend e Visual Studio in tre flussi di lavoro paralleli, scorrelati ma al tempo stesso correlati a te va in meltdown il cervello!
Non c'è verso di capirlo tutto e subito!
Connesso
Matteo Anelli

Vazkor: "Altro che Apple TV"

Monopoli

  • Hero Member
  • *****
  • Offline Offline
  • Post: 4.296
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #41 il: Febbraio 16, 2009, 00:19:49 »

Ok, dove stanno questi magici manuali? :D

Dentro l'help del Visual Studio, c'è un libro nuovo che si chiama, neanche troppo metafisicamente, XNA Game Studio 3.0. Neanche a farlo apposta, la programming guide, dopo un'introduzione genrica inizia proprio con.... LA CONTENT PIPELINE!!!!!!  ;D

Ok, almeno questo non è senza senso :D

Me lo leggo un po' vedo se riesco a dissipare questa sensazione di "merda come Renderware" :D
Connesso
Il mio blog agghiacciante
http://monopoliano.blogspot.com
E' Uscito! Compra qui: http://itunes.apple.com/us/album/crystal/id461134607

"Monopoli hai la voce da frocio ma sei un figo sull'Arsludicast."

Ziggybee

  • Administrator
  • Hero Member
  • *****
  • Offline Offline
  • Post: 8.383
  • Gamer Extraordinaire
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #42 il: Febbraio 16, 2009, 00:21:35 »

Io lavoreri di più all'attitudine al cambiamento.

Ma renderware fa davvero così schifo? Mi posso documentare in merito? Come può il motore dietro il racing game più bello (e pare pure con dei porting pc della madonna) del cosmo essere così brutto?

Mi riferisco a Burnout Paradise, eh!
Connesso
Matteo Anelli

Vazkor: "Altro che Apple TV"

Monopoli

  • Hero Member
  • *****
  • Offline Offline
  • Post: 4.296
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #43 il: Febbraio 16, 2009, 00:27:45 »

Io lavoreri di più all'attitudine al cambiamento.

Ma renderware fa davvero così schifo? Mi posso documentare in merito? Come può il motore dietro il racing game più bello (e pare pure con dei porting pc della madonna) del cosmo essere così brutto?

Mi riferisco a Burnout Paradise, eh!

In renderware che usa criterion non ha NIENTE a che vedere con quello che vende. Ecco come fa :D

Non ho problemi al cambiamento: non hai idea di quanti linguaggi ho usato e uso.
Ultimamente lavoro tanto con Python , ma in passato ho guadagnato soldi lavorando in VB6, in Java, in Avenue (Arcview) e, ultimo ma non meno importante, javascript :D

E' che qui mi sembra che si vuole essere allegri ed amichevoli, ma in realtà si è ben più complessi dei linguaggi a cui non si vuole somigliare perchè sono troppo complessi :D
Connesso
Il mio blog agghiacciante
http://monopoliano.blogspot.com
E' Uscito! Compra qui: http://itunes.apple.com/us/album/crystal/id461134607

"Monopoli hai la voce da frocio ma sei un figo sull'Arsludicast."

Ziggybee

  • Administrator
  • Hero Member
  • *****
  • Offline Offline
  • Post: 8.383
  • Gamer Extraordinaire
    • Mostra profilo
Re: Sviluppo XNA
« Risposta #44 il: Febbraio 16, 2009, 00:33:14 »

LOL
Connesso
Matteo Anelli

Vazkor: "Altro che Apple TV"
 

Pagina creata in 0.016 secondi con 15 interrogazioni al database.