Y a-t-il une alternative plus rapide à utiliser des textures dans Xna?

Assumer tous les tuiles qu'une carte nécessite des images existantes qui placent simplement sur un écran pour établir une carte de tuile? Ou faites-vous des images dans cet éditeur de carte et souhaitez-vous les sauvegarder?

J'ai lu ceci et votre autre poste sur les textures - s'ils sont toutes des images définies prêtes que vous souhaitez utiliser dans votre jeu ne pouvaient pas simplement les inclure dans le dossier de contenu et les références là-bas? Cela permet à XNA de compiler les textures du format XNB et vous ne devriez pas avoir les problèmes que vous expliquez.

Toutefois, si nous parlons complètement dynamique - ou vous créez une grosse image de la disposition des tuiles (au lieu de faire quelque chose comme une carte de tuile), je ne suis pas sûr de vous approcher de la question.

Si plusieurs tuiles utilisent la même texture, il suffira de le charger une seule fois.

Si l'utilisateur inclut des textures de certains formats de fichier, vous pouvez le convertir automatiquement en un format de texture / image qui est plus rapide pour vos besoins.

Puisque vous devez utiliser un format d'image personnalisé, si vous voulez (à la vitesse), vous pouvez tenter d'écrire des importateurs de pipeline de contenu personnalisés et des processeurs pour XNA ( http://msdn.microsoft.com/en-us/library/bb447754.aspx ), mais cela peut être surchargé pour ce dont vous avez besoin faire.

Je vois que vous voulez concevoir l'interface graphique aussi facilement que possible, même si ces problèmes vous obligent à utiliser une langue comme C ++ afin que vous puissiez utiliser DirectX. Dans Visual C ++, vous devriez toujours pouvoir profiter de visuel Layout Formulaires Windows Si vous utilisez Visual Studio.

Malheureusement, autant que je sache, il n'ya aucun moyen de dessiner directement un bitmap à l'écran de XNA; Il faut que tout soit mappé sur les objets de texture, qui sont par défaut tamponnés à la carte graphique. On dirait que vous parlez de beaucoup de carreaux, cependant, s'ils ne correspondaient pas à la texture maximale autorisée (je ne me souviens pas si c'était 1024 ou 4096 carrés ...) - Avez-vous essayé d'avoir un Texture non coupée à des fins de vitesse? Une autre alternative serait de charger vos carnets de paresseux dans des textures afin que l'utilisateur ne soit pas obligé d'attendre que tous soient chargés - pour un éditeur, l'utilisation d'une couleur de repli rose vif est généralement acceptable pendant la charge.

Aussi, y a-t-il quelque chose de manière intrinsèquement nécessaire pour écrire votre outil à XNA? Comme on dirait que vous écrivez l'outil séparément du moteur de jeu lui-même, vous pouvez trouver des solutions très acceptables dans WPF, y compris le dessin directement à partir de bitmapsources et des utilitaires de votre UI.

essayez-vous de les attirer tous en utilisant un seul fil d'exécution?

Essayez de multi-threading votre jeu. Le filetage en C # est assez facile et est supporté par XNA.

Au lieu de regarder votre écran dans son ensemble, essayez de le diviser en deux (ou plus) portions. Vous devrez peut-être ré-écrire la fonction que vous utilisez pour dessiner (j'espère bien que vous ne viendrez pas tout de même sur votre mode de tirage () !!) Pour prendre des coordonnées définissant les limites de vos régions de tirage.

Y a-t-il une raison pour laquelle vous n'avez pas considéré comme chargé de chargement de l'image une fois, puis en passant des coordonnées de x et y sur les coordonnées de x et y sur le shader pixel?

Vous définissez essentiellement le C # up comme ceci: p>

float4x4 World; 
float4x4 View; 
float4x4 Projection;

float xOffset;
float yOffset;

sampler TextureSampler; 

struct VS_INPUT { 
    float4 Position : POSITION0; 
    float4 Color    : COLOR0;
};

VS_INPUT Transform(VS_INPUT Input) { 
    VS_INPUT Output; 

    float4 worldPosition = mul(Input.Position, World); 
    float4 viewPosition = mul(worldPosition, View); 
    Output.Position = mul(viewPosition, Projection); 
    Output.Color = Input.Color;

    return Output; 
} 

float4 ColorTexture(VS_INPUT Input) : COLOR0{ 
    return Input.Color.rgba * tex2D(TextureSampler, float2(xOffset, yOffset));
} 

technique TransformColorTexture { 
    pass P0 { 
        VertexShader = compile vs_2_0 Transform(); 
        PixelShader = compile ps_2_0 ColorTexture(); 
    } 
}

Utiliser une texture par tuile n'est pas très efficace. Surtout car cela signifie que vous ne pouvez pas faire du lotting (dans un sens réel).

Si vous devez les avoir comme des textures séparées dans votre projet de contenu pour une raison quelconque (plus facile à éditer une tuile, etc.), vous pouvez facilement compiler facilement eux dans des tilleuls après le chargement. Comment vous faites cela est fondamentalement: p>

1: chargez un certain nombre de carreaux (disons 40 32 * 32 carreaux pour l'instant) P>

2: Couvrez une belle taille de texture pour le Tilemap: La racine carrée de 40 est de 6.Quelque chose, donc nous nous arrondirons jusqu'à 7,7 * 32 est 224, ce qui est agréable, mais 256 est plus agréable, permet de faire la texture 256x256. (Vous pouvez faire du code qui figure ceci à la volée) P>

3: Créer un rendeurAtGet2D qui est la taille souhaitée. p>

4: Activer Rendertarget. P>

5: Render des carreaux sur Rendertarget: P>

int x, y = 0;
foreach (var tile in allTiles)
{
    RenderTile(tile, x*32, y*32);
    x++;

    if (x >= 8)
    {
        x = 0;
        y++;
    }
}