[Module]SideViewFL - SideViewFaceLocation

Sujet: [Module]SideViewFL - SideViewFaceLocation Lun 10 Mar 2014 - 23:18

Introduction
Ce module contient des alternatives aux fonctions FaceLocation, FaceCharacter et FaceObject tenant compte de la perspective de la pièce.
[Module]SideViewFL - SideViewFaceLocation 1394490675-cercle

[Module]SideViewFL - SideViewFaceLocation 1394490675-cercle

Les fonctions définies par AGS correspondent à la situation à gauche : la vue de dessus (cf le mexicain).
Si le personnage joueur est situé au centre du cercle et le point à regarder est le point A, si l'angle entre l'horizontal et le point A fait moins de pi/4 (45°), le personnage regarde sur le coté, si l'angle est supérieure, il regarde vers le haut ou le bas. Mais dans une vue sur le coté, en perspective (à droite sur le dessin, cf le mexicain), ce cercle de décision est écrasé, on a plus un angle de pi/2, mais un angle plus petit (aplha), dépendant de la perspective.
C'est bien sur la même chose pour les personnages à huit directions, avec cette fois deux angles de décisions valant en vue de dessus pi/6 (30°) et pi/3 (60°).
[Module]SideViewFL - SideViewFaceLocation 1394490674-cercledir

[Module]SideViewFL - SideViewFaceLocation 1394490674-cercledir

Utilisations
Ce module contient donc quatre fonctions, FaceSVDirection, FaceSVLocation, FaceSVCharacter et FaceSVObject qui s'utilisent comme cela :

Code:: cEgo.FaceSVDirection(eUp);
cEgo.FaceSVLocation(150, 150);
cEgo.FaceSVCharacter(cBillbis);
cEgo.FaceSVObject(oWoman); // Blague de mauvais goût

Si vos personnages utilisent 8 directions, vous devez le déclarer comme cela, par exemple dans une fonction game_start() situé sous le script du module dans l'arborescence :

Code:: function game_start () {
SideViewFL.CharacterWithDiagonalLoops(cEgo, true);
SideViewFL.CharacterWithDiagonalLoops(cSamuel, true);
}

Si vos personnages se trouvent sur des surfaces de 'perspectives inversées', c'est à dire des surfaces où plus l'on monte vers le haut de l'écran, plus les choses se rapprochent de nous (par exemple les plafonds), vous devez le spécifier comme cela :

Code:: function region1_WalksOnto() () {
SideViewFL.CharacterWalkingOnTheRoof(cEgo, true);
}

Vous pouvez spécifier la perspective de la pièce de plusieurs façon. En pratique elle ne devrait pas trop changer d'une pièce à l'autre tant que vous n'avez pas des plans de caméra trop exotiques. Par défaut elle est réglée sur un horizon au milieu de la pièce, ou bien sur un aplatissement de 0,5.
Vous pouvez tout d'abord spécifier cet aplatissement :

Code:: SideViewFL.Flatness = 0.5; // float compris entre 0 et 1

Cet aplatissement correspond au degré d'aplatissement du cercle de décision du schéma n°1 à droite : il s'agit plus précisément du rapport entre le rayon vertical et le rayon horizontal. Demandez vous : Si mon perso va d'un mètre sur la droite, de combien de pixel vers la droite se déplace-t-il ? -> distance A. Si mon perso va d'un mètre vers le fond de la pièce, de combien de pixel vers le haut se déplace-t-il ? -> distance B. L'aplatissement vaudra B/A. En général, il tourne autour de 0,5 pour une vue de coté.

Vous pouvez aussi spécifier la coordonnée y de votre ligne d'horizon :

Code:: SideViewFL.HorizonLevel = 120;

Mais le modèle derrière cette méthode est un peu moins précis pour l'instant.
Enfin, ça devrai le faire quand même, hein. Le modèle est maintenant ultra-précis !

Enfin, vous pouvez spécifier vous même directement les angles de décisions (en radiant, par rapport à l'horizontal) :

Code:: SideViewFL.Angle4Dir = Maths.Pi/6.0;
SideViewFL.Angle8Dir1 = Maths.Pi/8.0;
SideViewFL.Angle8Dir2 = Maths.Pi/4.0; // Angle8Dir1 <= Angle8Dir2

Angles définies comme ceci :
[Module]SideViewFL - SideViewFaceLocation 1394490674-angledefinition

/!\ modifier les valeurs HorizonLevel ou Flatness modifieront les valeurs Angle4Dir, Angle8Dir1, Angle8Dir2.

Imperfections notables
Pour l'instant, le module ne supporte pas les "surfaces inversées" comme le plafond ou lorsque les pieds du personnages sont situés au dessus de la ligne d'horizon (les cas où plus le personnage monte à l'écran, plus il s'éloigne du fond de la pièce). Ajouté dans la version 1.2 !
Cependant, lorsque le personnage et par terre et qu'il regarde un objet au plafond, ou réciproquement, le module n'est pas capable de déterminer si le personnage doit regarder vers le fond ou vers le devant : le personnage et le point à regarder doivent être du même coté de l'horizon. confus

Il ne supporte pas la déformation du cercle de décision relatif à un point de fuite (l'angle opposé au point de fuite serait plus obtus que l'angle pointant vers ce point de fuite).
/!\ Le module contient un enum global fort malhabilement nommé SpecifyDirection, tout comme dans ce célèbre tutoriel. Gare aux conflits !
De plus, cet enum deviendra obsolète avec AGS 3.3.1.

Remerciment
Merci à Kitai pour ce topic. J'espère avoir été un élève appliqué.
Merci à Pidem pour m'avoir aidé à établir l'équation derrière HorizonLevel.

Licence
Faites littéralement ce que vous voulez avec ce module.

Souces
Header

Code:: // SideViewFL header, version 1.2
//
// Author: Billbis
//
// Abstract:
//
// Alternative FaceLocation, FaceCharacter and FaceObject functions that take into account
// the perspective of the room.
//
// Dependencies:
//
// Made for AGS 3.3.0. Might work with previous and future AGS versions.
//
// Functions:
//
// Character.FaceSVDirection(SpecifyDirection Dir, BlockingStyle BStyle)
// Will trun the character to face the specified direction.
// e.g.: cEgo.FaceSVDirection(eUp);
//
// Character.FaceSVLocation(int x, int y, BlockingStyle BStyle)
// Will turn the character to face the specified location (Room coordinates).
// e.g.: cEgo.FaceSVLocation(150, 150);
//
// Character.FaceSVCharacter(Character* toFace, BlockingStyle BStyle)
// Will turn the character to face the specified character.
// e.g.: cEgo.FaceSVCharacter(cBillbis);
//
// Character.FaceSVObject(Object* toFace, BlockingStyle BStyle)
// Will turn the character to face the specified object.
// e.g.: cEgo.FaceSVCharacter(oKey);
//
// Configuartion:
//
// If your characters are using 8 direction loops, you must declare it with the CharacterWithDiagonalLoops function,
// for example in a game_start() function located bellow this script module.
// e.g.: SideViewFL.CharacterWithDiagonalLoops(cEgo, true);
//
// Optionnal:
//
// When located on a 'inverte perspective' surface (i.e. a area when the lower theY coordinate, the closer the things are, e.g. a roof),
// you should call the CharacherWalkingOnTheRoof function.
// e.g.: SideViewFL.CharacherWalkingOnTheRoof(cEgo, true);
//
// You can specify the 'flatness' of the game with SideViewFL.Flatness. Float value between 0 and 1.
// Warning: resets Angle4Dir, Angle8Dir1 and Angle8Dir2 values.
// e.g.: SideViewFL.Flatness = 0.5;
//
// Alternatively, you can specify the Y coordinate of your horizon. Int value.
// Consider using 'SideViewFL.Flatness = 1;' if your horizon is at infinity.
// Warning: resets Flatness, Angle4Dir, Angle8Dir1 and Angle8Dir2 values.
// e.g.: SideViewFL.HorizonLevel = 120;
//
// N.B.: the following angle are relative to the horizontal.
//
// You can specify the decision angle for 4 direction loops character, in Radiant. Float value between 0 and Pi/2.
// e.g.: SideViewFL.Angle4Dir = Maths.Pi/3.0;
//
// You can specify the decision angle for 8 direction loops character separating horizontal to digonal loops, in Radiant.
// Float value between 0 and min(Pi/2, Angle8Dir2).
// e.g.: SideViewFL.Angle8Dir1 = Maths.Pi/6.0;
//
// You can specify the decision angle for 8 direction loops character separating diagonal to vertical loops, in Radiant.
// Float value between max(0, Angle8Dir1) and Pi/2.
// e.g.: SideViewFL.Angle8Dir2 = Maths.Pi/2.0;
//
// Caveats:
//
// Contain a direction enum that will become obsolete in AGS 3.3.1. Beware of potential conflicts!
//
// Revision history:
//
// 2014/03/12: Fix another math error and a stupid mistake. Add 'invert perspective' surfaces support.
// 2014/03/11: Fix two math errors + new model behind HorizonLevel method.
// 2014/03/10: original release.
//
// License:
//
// SideViewFL is publish under the terms of the
// Do What The Fuck You Want To Public License, Version 2
//
// This program is free software. It comes without any warranty, to
// the extent permitted by applicable law. You can redistribute it
// and/or modify it under the terms of the Do What The Fuck You Want
// To Public License, Version 2, as published by Sam Hocevar. See
// http://sam.zoy.org/wtfpl/COPYING for more details.
//
// Thanks:
//
// Kitai, Pidem

//////////////////////////
// Various declarations //
//////////////////////////

enum SpecifyDirection {
  eUp,
  eLeft,
  eRight,
  eDown,
  eUpRight,
  eUpLeft,
  eDownRight,
  eDownLeft,
eNone
};

struct SideViewFL {

   import static attribute float Angle4Dir;
   import static float get_Angle4Dir();// $AUTOCOMPLETEIGNORE$
   import static void set_Angle4Dir(float input);// $AUTOCOMPLETEIGNORE$

   import static attribute float Angle8Dir1;
   import static float get_Angle8Dir1();// $AUTOCOMPLETEIGNORE$
   import static void set_Angle8Dir1(float input);// $AUTOCOMPLETEIGNORE$
   import static attribute float Angle8Dir2;
   import static float get_Angle8Dir2();// $AUTOCOMPLETEIGNORE$
   import static void set_Angle8Dir2(float input);// $AUTOCOMPLETEIGNORE$

   import static attribute float Flatness;
   import static float get_Flatness();// $AUTOCOMPLETEIGNORE$
   import static void set_Flatness(float input);// $AUTOCOMPLETEIGNORE$

   import static attribute int HorizonLevel;
   import static int get_HorizonLevel();// $AUTOCOMPLETEIGNORE$
   import static void set_HorizonLevel(int input);// $AUTOCOMPLETEIGNORE$

   /// Does the character have 8 direction loops?
   import static void CharacterWithDiagonalLoops(Character *chara, bool boule);
   /// Does the carracter currently standing on an invert perspective surface (i.e. a roof)?
   import static void CharacherWalkingOnTheRoof(Character *chara, bool boule);
};

/// Trun the character to face the specified direction.
import void FaceSVDirection(this Character*, SpecifyDirection=eNone, BlockingStyle=eBlock);
/// Turn the character to face the specified location (Room coordinates).
import void FaceSVLocation(this Character*, int x, int y, BlockingStyle BStyle = eBlock);
/// Turn the character to face the specified character.
import void FaceSVCharacter(this Character*, Character* toFace, BlockingStyle BStyle = eBlock);
/// Turn the character to face the specified object.
import void FaceSVObject(this Character*, Object* toFace, BlockingStyle BStyle = eBlock);

Script

Code:: // FaceIsoLocation script

float Angle4Dir;
float Angle8Dir1;
float Angle8Dir2;
float Flatness;
int HorizonLevel;
bool IsCharacterWithDiagonalLoops[];
bool IsCharacterWalkingOnTheRoof[];

// Utilitary function
float SideView_Abs(float x) // return absolute value
{
if (x >= 0.0) return x;
   else return -1.0*x;
}

// struct static definitions
static float SideViewFL::get_Angle4Dir()
{
   return Angle4Dir;
}

static void SideViewFL::set_Angle4Dir(float input)
{
   if (input >= 0.0 && input <= Maths.Pi/2.0) {
   Angle4Dir = input;
   }
}

static float SideViewFL::get_Angle8Dir1()
{
   return Angle8Dir1;
}

static void SideViewFL::set_Angle8Dir1(float input)
{
   if (input >= 0.0 && input <= Maths.Pi/2.0 && input <= Angle8Dir2) {
   Angle8Dir1 = input;
   }
}

static float SideViewFL::get_Angle8Dir2()
{
   return Angle8Dir2;
}

static void SideViewFL::set_Angle8Dir2(float input)
{
   if (input >= 0.0 && input <= Maths.Pi/2.0 && input >= Angle8Dir1) {
   Angle8Dir2 = input;
   }
}

static float SideViewFL::get_Flatness()
{
   return Flatness;
}

static void SideViewFL::set_Flatness(float input)
{
   if (input >= 0.0 && input <= 1.0) {
   Flatness = input;
   Angle4Dir = Maths.ArcCos(Flatness)/2.0;
   Angle8Dir1 = Maths.ArcCos(Flatness)/3.0;
   Angle8Dir2 = Maths.ArcCos(Flatness)/1.5;
   }
}

static int SideViewFL::get_HorizonLevel()
{
   return HorizonLevel;
}

static void SideViewFL::set_HorizonLevel(int input)
{
   float horizonYf;
   horizonYf = IntToFloat(input);
   float RoomHeightf = IntToFloat(Room.Height);
   Flatness = Maths.ArcTan((RoomHeightf - 2.0*horizonYf)/RoomHeightf)/Maths.Pi + 0.5; //
Angle4Dir = Maths.ArcCos(Flatness)/2.0;
   Angle8Dir1 = Maths.ArcCos(Flatness)/3.0;
   Angle8Dir2 = Maths.ArcCos(Flatness)/1.5;
}

static void SideViewFL::CharacterWithDiagonalLoops(Character *chara, bool boule)
{
   IsCharacterWithDiagonalLoops[chara.ID] = boule;
}

static void SideViewFL::CharacherWalkingOnTheRoof(Character *chara, bool boule)
{
   IsCharacterWalkingOnTheRoof[chara.ID] = boule;
}

// Module core functions
void FaceSVDirection(this Character*, SpecifyDirection Dir, BlockingStyle BStyle)
{
   if(Dir == eUp) this.FaceLocation(this.x, this.y-1, BStyle);
   else if(Dir == eLeft) this.FaceLocation(this.x-1, this.y, BStyle);
   else if(Dir == eRight) this.FaceLocation(this.x+1, this.y, BStyle);
   else if(Dir == eDown) this.FaceLocation(this.x, this.y+1, BStyle);
   else if(Dir == eUpRight) this.FaceLocation(this.x+1, this.y-1, BStyle);
   else if(Dir == eUpLeft) this.FaceLocation(this.x-1, this.y-1, BStyle);
   else if(Dir == eDownRight) this.FaceLocation(this.x+1, this.y+1, BStyle);
   else if(Dir == eDownLeft) this.FaceLocation(this.x-1, this.y+1, BStyle);
}

void FaceSVLocation(this Character*, int x, int y, BlockingStyle BStyle)
{
   int deltaX = x - this.x;
   int deltaY = this.y - y; //AGS Y axes is pointing down
   float deltaXf = IntToFloat(deltaX);
   float deltaYf = IntToFloat(deltaY);
   float alpha;
   if (deltaX >= 0) {
   alpha = Maths.ArcTan2(deltaYf, deltaXf);
   } else {
   alpha = Maths.ArcTan2(deltaYf, -deltaXf);
   }

   if (IsCharacterWithDiagonalLoops[this.ID] == false) { // Four loops character
   if (deltaX >= 0 && SideView_Abs(alpha) <= Angle4Dir) {
   this.FaceSVDirection(eRight, BStyle);
   } else if (deltaX < 0 && SideView_Abs(alpha) <= Angle4Dir) {
   this.FaceSVDirection(eLeft, BStyle);
   } else if (deltaY >0) {
   if (IsCharacterWalkingOnTheRoof[this.ID]) { // Invert perspective.
   this.FaceSVDirection(eDown, BStyle);
   } else {
   this.FaceSVDirection(eUp, BStyle);
   }
   } else {
   if (IsCharacterWalkingOnTheRoof[this.ID]) {
   this.FaceSVDirection(eUp, BStyle);
   } else {
   this.FaceSVDirection(eDown, BStyle);
   }
   }
   } else { // Eight loops character
   if (deltaX >= 0 && SideView_Abs(alpha) <= Angle8Dir1) {
   this.FaceSVDirection(eRight, BStyle);
   } else if (deltaX >= 0 && SideView_Abs(alpha) <= Angle8Dir2) {
   if (deltaY >=0) {
   if (IsCharacterWalkingOnTheRoof[this.ID]) {
   this.FaceSVDirection(eDownRight, BStyle);
   } else {
   this.FaceSVDirection(eUpRight, BStyle);
   }
   } else {
   if (IsCharacterWalkingOnTheRoof[this.ID]) {
   this.FaceSVDirection(eUpRight, BStyle);
   } else {
   this.FaceSVDirection(eDownRight, BStyle);
   }
   }
   } else if (deltaX < 0 && SideView_Abs(alpha) <= Angle8Dir1) {
   this.FaceSVDirection(eLeft, BStyle);
   } else if (deltaX < 0 && SideView_Abs(alpha) <= Angle8Dir2) {
   if (deltaY >=0) {
   if (IsCharacterWalkingOnTheRoof[this.ID]) {
   this.FaceSVDirection(eDownLeft, BStyle);
   } else {
   this.FaceSVDirection(eUpLeft, BStyle);
   }
   } else {
   if (IsCharacterWalkingOnTheRoof[this.ID]) {
   this.FaceSVDirection(eUpLeft, BStyle);
   } else {
   this.FaceSVDirection(eDownLeft, BStyle);
   }
   }
   } else if (deltaY >=0) {
   if (IsCharacterWalkingOnTheRoof[this.ID]) {
   this.FaceSVDirection(eDown, BStyle);
   } else {
   this.FaceSVDirection(eUp, BStyle);
   }
   } else {
   if (IsCharacterWalkingOnTheRoof[this.ID]) {
   this.FaceSVDirection(eUp, BStyle);
   } else {
   this.FaceSVDirection(eDown, BStyle);
   }
   }
   }
}

void FaceSVCharacter(this Character*, Character* toFace, BlockingStyle BStyle)
{
   this.FaceSVLocation(toFace.x, toFace.y, BStyle);
}

void FaceSVObject(this Character*, Object* toFace, BlockingStyle BStyle)
{
   int x, y;
   x = toFace.X + Game.SpriteWidth[toFace.Graphic]/2;
   y = toFace.Y - Game.SpriteHeight[toFace.Graphic]/2;
   this.FaceSVLocation( x, y, BStyle);
}

function game_start () {
   IsCharacterWithDiagonalLoops = new bool[Game.CharacterCount];
   IsCharacterWalkingOnTheRoof = new bool[Game.CharacterCount];
   int i = 0;
   while (i < Game.CharacterCount) {
   IsCharacterWithDiagonalLoops[i] = false;
   IsCharacterWalkingOnTheRoof[i] = false;
   i++;
   }
   SideViewFL.set_Flatness(0.5);
}

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Mar 11 Mar 2014 - 8:56

Haha, ça commence bien.
Petite erreur mathématique (décidément !) : il faut bien évidement remplacer ça :

Code:: static void SideViewFL::set_Flatness(float input)
{
   if (input >= 0.0 && input <= 1.0) {
   Flatness = input;
   Angle4Dir = Maths.ArcCos(Flatness)/2.0;
   Angle8Dir1 = Maths.ArcCos(Flatness)/6.0;
   Angle8Dir2 = Maths.ArcCos(Flatness)/3.0;
   }
}

par ça :

Code:: static void SideViewFL::set_Flatness(float input)
{
   if (input >= 0.0 && input <= 1.0) {
   Flatness = input;
   Angle4Dir = Maths.ArcCos(Flatness)/2.0;
   Angle8Dir1 = Maths.ArcCos(Flatness)/3.0;
   Angle8Dir2 = Maths.ArcCos(Flatness)/1.5;
   }
}

et idem pour les lignes 83 et 84. Je vous prépare un patch ce soir.
Sinon grâce à Pidem, j'ai amélioré le modèle derrière HorizonLevel.
Anciennement :

Code:: static void SideViewFL::set_HorizonLevel(int input)
{
   if (input >= 0 && input <= Room.Height) {
   float horizonYf;
   horizonYf = IntToFloat(input);
   int RoomHeight = Room.Height;
   float RoomHeightf = IntToFloat(RoomHeight);
   Flatness = -1.0 *(horizonYf / RoomHeightf) + 1.0; //Linear decrease of flatness. Probably not the best model. Arctan ?

Nouveau modèle :

Code:: static void SideViewFL::set_HorizonLevel(int input)
{
   float horizonYf;
   horizonYf = IntToFloat(input);
   float RoomHeightf = IntToFloat(Room.Height);
   Flatness = Maths.ArcTan((RoomHeightf-horizonYf)/RoomHeightf)/Maths.Pi + 0.5;

Ce sera dans la version publié ce soir.

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Mar 11 Mar 2014 - 20:10

Module mis à jour, cf le premier post.
Corrections de deux erreurs + nouveau modèle pour la méthode HorizonLevel.
Pour info, vous pouvez tester le module avec des trucs comme ça:

Code:: // room script file
function facetruc(this Character*, int x, int y) {
   DynamicSprite *sprite = DynamicSprite.Create(System.ViewportWidth, System.ViewportHeight);
   DrawingSurface *surface = sprite.GetDrawingSurface();
   surface.DrawImage(x - GetViewportX(), y - GetViewportY(), Mouse.GetModeGraphic(eModeWalkto));
   surface.Release(); // Technical stuff to display the beautiful overlay we have drawn.
   Overlay *overlay = Overlay.CreateGraphical(0, 0, sprite.Graphic, true);

   this.FaceSVLocation(x, y);
   Wait(30);

   overlay.Remove(); //Cleaning a little bit behind us.
   sprite.Delete();
   overlay = null ;
}

function facetruc2(this Character*, int amount) {
   int x = player.x;
   int y = player.y;
   this.facetruc(x, y-amount);
   this.facetruc(x+amount, y-amount);
   this.facetruc(x+amount, y);
   this.facetruc(x+amount, y+amount);
   this.facetruc(x, y+amount);
   this.facetruc(x-amount, y+amount);
   this.facetruc(x-amount, y);
   this.facetruc(x-amount, y-amount);
}

function hHotspot1_Interact()
{
   SideViewFL.CharacterWithDiagonalLoops(cEgo, true);
   player.facetruc2(100);
}

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Mer 12 Mar 2014 - 12:12

Bon boulot Bill !
Merci pour cette contribution de qualité comme d'habitude clin d'oeil

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Mer 12 Mar 2014 - 14:51

Effectivement j'admire ce module. De mon humble perspective, le travail d'encapsulation m'a l'air bien mené clin d'oeil

Le calcul semble intelligent, je ne suis pas bien sûr d'avoir tout compris avec la ligne d'horizon : est-ce que ça ne présuppose pas un "premier-plan" situé tout en bas de l'écran ?

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Mer 12 Mar 2014 - 15:45

Merci.

Je ne suis pas sûr de saisir ta remarque, Kitai.

Billbis a écrit:: Imperfections notables
Pour l'instant, le module ne supporte pas les "surfaces inversées" comme le plafond ou lorsque les pieds du personnages sont situés au dessus de la ligne d'horizon (les cas où plus le personnage monte à l'écran, plus il s'éloigne du fond de la pièce).

Tu parles de ça ? Je suis au courant. triste

Ou bien de ça ? :

Code:: Flatness = Maths.ArcTan((RoomHeightf - horizonYf)/RoomHeightf)/Maths.Pi + 0.5;

La courbe.
Ouuuups. Erreur de math, à nouveau. rougit

En effet il faut faire :

Code:: Flatness = Maths.ArcTan((RoomHeightf - 2.0*horizonYf)/RoomHeightf)/Maths.Pi + 0.5;

La courbe.
Quand l'horizon est à + l'infini (coordonnée infiniment négative), l'aplatissement vaut 1. Quand l'horizon est au mileu de la piéce, il vaut 0,5. Quand il est tout en bas de la pièce, l’aplatissement vaut pas loin de 0 (bon, à la réflexion, aplatissement n'est peut - être pas le terme le plus judicieux, vu que la valeur représente son inverse grand sourire

).
A l'occasion, je ferai un petit post trigonométrique, mais en ce moment je n'ai pas trop le courage. confus

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Mer 12 Mar 2014 - 17:36

Billbis a écrit:: Quand l'horizon est à + l'infini (coordonnée infiniment négative), l'aplatissement vaut 1. Quand l'horizon est au mileu de la piéce, il vaut 0,5. Quand il est tout en bas de la pièce, l’aplatissement vaut pas loin de 0 (bon, à la réflexion, aplatissement n'est peut - être pas le terme le plus judicieux, vu que la valeur représente son inverse ).

Imaginons qu'on soit en 320*240. Je fais une pièce où mon horizon est à 120 et où je dessine à partir du 200ème pixel le sous-sol, ou la terre, ou autre chose. Bref, l'idée c'est qu'à l'écran, la "ligne horizontale du sol" se trouve 40 pixels au-dessus du bas de l'écran. Tu vois que ç'aura un impact sur l'applatissement, tu ne penses pas ?

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Mer 12 Mar 2014 - 21:18

Désolé Kitai, mais je pense que je n'ai toujours pas saisi. Tu peux faire un schéma où un screenshot ? De toute façon, l’aplatissement est réglable à la volée.

Nouvelle version : 1.2
- correction d'une erreur de calcul dans la méthode HorizonLevel
- correction d'une erreur d'étourderie : les personnages regardant en bas à gauche regardaient en fait en bas à droite.
- support des surfaces de 'perspectives inversée' !
Si vos personnages se trouvent sur des surfaces de 'perspectives inversée', c'est à dire des surfaces où plus l'on monte vers le haut de l'écran, plus les choses se rapprochent de nous (par exemple les plafonds), vous devez le spécifier comme cela :

Code:: function region1_WalksOnto() () {
SideViewFL.CharacterWalkingOnTheRoof(cEgo, true);
}

Cependant, lorsque le personnage et par terre et qu'il regarde un objet au plafond, ou réciproquement, le module n'est pas capable de déterminer si le personnage doit regarder vers le fond ou vers le devant : le personnage et le point à regarder doivent être du même coté de l'horizon. confus

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Mer 12 Mar 2014 - 22:09

[Module]SideViewFL - SideViewFaceLocation Fuite10

Vois les lignes de fuite modifiées par la présence/l'absence du sous-sol terrestre !

Sujet: Re: [Module]SideViewFL - SideViewFaceLocation Jeu 13 Mar 2014 - 8:50

Merci du schéma Kitai, c'est très clair. sourire

Tu as tout à fait raison, la présence d'un sous-sol (et même d'un GUI permanent en bas de l'écran) aura bien un impact sur l'aplatissement (enfin, ça dépend aussi du style du dessin), qui n'est pas pris en compte dans la méthode HorizonLevel. Il sera donc préférable de définir directement un aplatissement (via Flatness).
Après, je pense que l'effet est quand même minime. En pratique, laisser le flatness à 0.5 tout le long du jeu devrai suffire dans la plupart des situations.

» [Module] ShowInteractiveAreas
» Razorblade 3D 1.0, module 3D
» Module PDFFile
» Plateau (module)
» Module InfoBulles