Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - lightbug

#46
Scripting / incremento con while
Febrero 02, 2020, 05:23:50 PM
Jaja arranco leyendo la página y decía "Por favor, procurad que el tono de esta conversación no suba a más ..." ...  here we go again
 
 
 
Cita de: Jhonatan00_00 date=1580416077En este último código que ha puesto Francoe1 ya hay montones de comprobaciones por cada frame lo quiera o no y tampoco entiendo por que a los programadores mas avanzados les gusta tanto crear variables para llamar a las cosas como quieren y no por su nombre, por ejemplo, en lugar de poner Input.GetKeyDown(KeyCode.F) y ya está, primero crea una variable para llamar a KeyCode.F como Key (lo que es mas trabajo tanto para el programador como para el PC y es mas complicado) y después usa esa variable para un If que no es una operación matemática ni nada complejo.
   


Eso es buena práctica de programación, y probablemente no lo veas ahora, pero tiene todo el sentido del mundo. No es simple capricho.
 
Keycode: Este me parece el más obvio de todos. El script no se llama "DetectTheFKeyTime", osea que asume una "Key" genérica. Que pasa si le pasás el código a alguién que no tenga la tecla F de su teclado? (no se, se le cayo pegamento justo en el contacto). Claramente esta persona se queda sin poder hacer sus propias mediciones porque el programador responsable no supo proyectar, algo clave en este rubro. Como se arregla, posibilitando la selección de otras inputs, es tu problema actual? No, puede ser el de mañana? quién sabe...
 
Evento: Si tuvieras que detectar esta tecla en 15 monobehaviours distintos, tendrías que copiar y pegar todo el código en cada uno. Bueno, ya no es necesario, porque suscribiéndote al evento deseado simplemente le indicás el método a llamar y el proceso ocurre "under the hood".
 

// Action<float> Pepe --> void Pepe( float arg )
 
public class UnMonoB : MonoBehaviour
{
[SerializeField]
     DetectKeyTime detectKey = null;
 
     void OnEnable()
     {
        detectKey.EventFinish += EventFinish;
     }
 
     void OnDisable()
     {
        detectKey.EventFinish -= EventFinish;
     }
 
     void EventFinish( float duration )
     {
        // tu código...
     }
}

 
Condicionales: Los if esto o if aquello no representan el problema, muchos de estos procesos corresponden a decisiones lógicas irrelevantes. La papa está la tareas específicas, es decir una vez que ya ingresaste en alguna función o método, quizás el manejo de memoria, la creación de basura, multi threading, etc.
 
Dicho esto, la programación no está en hacer que algo simplemente funcione (eso lo hace cualquiera leyendo las referencias) si esto fuera así muchos investigadores, matemáticos y científicos que usan python o matlab para programar serían tremendos programadores (y claramente no lo son, uno se da cuenta). Para ellos, que quieren ser 100% funcionales va perfecto, que hagan todo el spaghetti que quieran (ya que simplemente necesitan apretar un botón y que la com***dora haga un cálculo una vez y listo). Un buen programador ve más allá de lo obvio, está proyectando soluciones a problemas (no errores) que quizás no existen en el momento, pero que seguramente van a aparecer. Cosas que pueden solucionarse con  modularidad, abstracción, dependencia, extensibilidad, etc.
 
En mi caso personal esto lo viví de una manera muy graciosa, un profesor de una materia de redes nos pidió hacer un trabajo práctico. Lo hice, todo perfecto, el programa a desarrollar debía leer un archivo txt con unas IP, después clasificarlas y demás. La cosa es que se lo entregué, el abrió el programa y a la hora de poner el argumento (Debía de ser "ip.txt") puso ""#$$"#ADF!!!!!¡¡¡?-----a1" ... y claro todo falló. Desaprobado. Cual fue el error? que yo como programador pensé que todo iban a ser buenos chicos, chicos de bien y poner "ip.txt"...grave error.
 
 
 
---> Lo del "?." lo hizo para cancherear, total y absolutamente, no es la primera vez .
 
 
 
Cita de: Jhonatan00_00 date=1580466881Pero a veces nos complicamos mas de la cuenta para hacer cosas sencillas y desde lo poco que conozco, se que por ejemplo cuando usamos time.Deltatime tras ese comando que Unity nos facilita hay una variable que va sumando al igual que si la creamos nosotros y que si usamos time.Deltatime 40 veces, cada vez es un contador nuevo que ha creado Unity, por tanto una variable invisible que nos consume recursos
   


La memoria ocupada por un float no es el "problema" aquí. La cosa está en llamar a esa variable múltiples veces desde una clase externa, siendo esto absolutamente innecesario. Sé que suena raro, desde ya que arrancar poniendo el foco en el DeltaTime no es algo que va a ser relevante frente al resto de las complicaciones que conlleva la creación de un juego (gráficos, lógica, networking, audio, manejo de memoria, etc). Ahora, si aislas todo y te ponés a pensar en lo que implica esto, estas llamando X veces (Ojo al piojo, X puede ser 40 como 40000000) a un valor que no cambia durante el frame, y que lo creas o no tiene un costo (no es gratis). Muchas veces está bien si estás en modo funcional y necesitas terminar algo de la noche a la mañana. Ahora si vas a hacerlo de forma seria sí hay un problema. Todo dependerá del contexto y de cuán adentrado estés.
 
Por ej si pruebas este simple script (usando stopWatch) que incrementa un valor a (a1 y a2):
 

using UnityEngine;
using System.Diagnostics;
public class test : MonoBehaviour
{
    public int count = 4000;
    void Update()
    {
        long resultTimeDT = 0;
        long resultDT = 0;
        float a1 = 0f;
        float a2 = 0f;
        float dt = Time.deltaTime;
        Stopwatch watch = new Stopwatch();
        watch.Start();
        for( int i = 0 ; i < count ; i++ )
            for( int j = 0 ; j < count ; j++ )
                a1 += Time.deltaTime;
        watch.Stop();
        resultTimeDT = watch.ElapsedMilliseconds;
        watch.Restart();
        for( int i = 0 ; i < count ; i++ )
            for( int j = 0 ; j < count ; j++ )
                a2 += dt;
        watch.Stop();
        resultDT = watch.ElapsedMilliseconds;
        print(string.Format("Time.deltaTime (ms) = {0} con a = {2} --- dt (ms) = {1} con a = {3}", resultTimeDT , resultDT , a1 , a2 ) );
       
    }
}

 
Mis resultados para count = 4000 (osea x2 de 4000^2 = 32 millones de incrementos):
 

 
Vas a notar la diferencia. Otra vez, ¿es super relevante ver el tema del Dt? no, pero si minimizar el efecto no cuesta nada mejor. ¿Vas a necesitar llamar 32 millones de veces un Time.deltaTime? nunca en la vida, si es así claramente estás haciendo algo mal. Esos casi 300 ms de más claramente justifican el definir un simple float.
 
 
 
Saludos
#47
En mi caso recientemente me di cuenta de que durante gran parte de mi vida (un 99.99998%) estuve usando blender mal (y exportando mal también). Resulta que estaba usando el "frente" a la vista que se logra apretando el numpad "3" (para los que lo usen van a entender), osea el plano YZ. En realidad el frente se considera a la vista lograda con "1" (no "3"), es decir, el plano XY (X a derecha, Y hacia adelante Z hacia arriba ---> Right handed). Que pasaba? que siempre debía de rotar 90 grados el modelo.
 
Blender usa coordenadas "Right Handed" vs las "Left handed" de Unity, de acá la necesidad de transformar los ejes. En las opciones de exportación podés retransformar los ejes, yo estaba asumiendo que el problema era el otro (el sistema de coordenadas) cuando en realidad era que yo mismo estaba rotando el modelo en blender.
 
Con respecto a las animaciones estropeadas, si tenés en cuenta bien los ejes podés retransformar todo a Unity sin perder todo (Seguramente podés lograrlo desde el mismo Blender modificando los transform o algo por el estilo).
 
En fin, no se si está relacionado a tu problema pero lo menciono ya que después de tanto tiempo se me dió por mirar los tres pequeños ejes que aparecían en el visor .
#48
Arte / Opinión arte pyxel o dibujo nuevo proyecto.
Enero 29, 2020, 12:39:24 AM
Cita de: maikai date=1580246156Hola a todos. Soy un poco novato en Unity 2D y me gustaría hacer un juego sencillito , pero el caso es que estoy pensando que tipo arte elegir. No sé si elegir Pyxelart o Dibujos hechos por mi tipo carton o algo similar. La cosa está me gustaría elegir el arte más sencillo de llevar en Unity 2D. De Pyxel art lo tengo mucha idea aunque me llaman algunos juegos indies y lo me importaría aprender y de dibujo pues tengo tablets gráfica pero no me e metido a fondo.
   


Hola @maikai, primero dejame decirte que es "pixel" no "pyxel", lo aclaro por si querés buscar material por ahí.
 
Cita de: maikai date=1580246156Según vuestra opinión que es más fácil de estos estilos a la hora de programar y animar ???
   


Arriba ya lo explicaron pero bueno... Claramente usar "Sprites con partes separadas" es mucho más amigable y fácil. Tenés dos grupos generales:
 
1 Sprite completo (tipo spritesheets por ej): Basicamente dibujar cada cuadro desde 0. Para mi infinitamente más difícil, esto es porque cada pequeño movimiento requiere de un frame completamente nuevo. Claro que depende de la calidad que busques, una cosa es agarrar el paint y dibujar con el pincel en un solo color. Otra muy distinta es buscar calidad y detalle. Ah y no lo mencioné, cada nuevo personaje debés hacerlo de cero.
 
Ej Sonic:
 

 
2 Sprites con partes separadas (brazos, torso, cabeza, etc): te permite reutilizar las partes y animarlas dentro de Unity (podés hasta reemplazar partes mediante animación). Si estás usando los Bones 2D podés hacer rigging en el mismo Unity, todo mucho más fácil. Podés reutilizar animaciones (siempre y cuando las partes animadas tengan el nombre que busca el clip de animación).
 
 
 
Saludos
 
 
#49
Scripting / Gravedad moldeable
Enero 26, 2020, 03:15:49 AM
Cita de: Igor date=1579983991@lightbug tiene un asset muy bueno que hace eso (pero en 2d)
   



Cita de: nomoregames date=1579986152Si... si ya lo pensé, pero no quiero llenar la escena de colliders, y aparte, tampoco sabría como hacerlo... jejejeje
   


Yo tampoco tengo en claro como haría algo así. Se me ocurre recorrer toda la escena (o por lo menos lo relevante) e ir sampleando normales mediante algun cast. Puede parecer una locura pero no, no es tan demandante, sobretodo si se hace una sola vez (además de que se puede hacer en el mismo editor ).
 
El tema de los colliders puede ser algo pesado de hacer, pero poder se puede.
 
Ya que está dejo un video que encontré recientemente donde el autor dice como hizo lo que hizo (no se si es 100% lo que querés pero puede sumar):
 


   
eature=oembed">

 
Y él/ella dice:
 
" I do a raycast from the player to the center of each gravity body collider in the scene, check for which raycasthit point is the nearest, then use the normal to determine the gravity direction each timestep. Hope that gives you an idea! "
#50
Scripting / Gravedad moldeable
Enero 25, 2020, 09:03:31 PM
Cita de: nomoregames date=1579888786if (Physics.Raycast(transform.position,transform.forward, out hit, 10000)){ transform.rotation = Quaternion.LookRotation(-hit.normal); RB.AddForce(-hit.normal * 100); RB.velocity = ( transform.up * Input.GetAxis("Vertical") * 10);
   


HOla, Sumando a lo que dijo @Igor, fijate que en las líneas de RB en una estás agregando fuerzas, todo bien, pero después estás pisando la velocidad directamente (anulando lo anterior). Está bien eso?
 
El efecto está muy bueno,  lo quiero implementar para mi asset, para mi este efecto siempre funcionó de manera algo predictiva o usando un campo vectorial (no solo es un cast y listo. Fijate que cuando salta hacia un muro recto, lentamente va cambiando la gravedad).
 
Predictiva: Una posibilidad puede ser que (por ej) cuando mario salta mientras corre tenés el típico caso del tiro oblicuo (caso general), con eso podés detectar en el aire si va a colisionar con una pared varios frames antes (simplemente mediante la velocidad que tiene), de esta forma podés ir rotando a mario antes de que toque la superficie. Con planetas super suavizados no te das cuenta, pero con superficies más abruptas es útil.
 
Campo vectorial (y para mi la que usó nintendo): es calcular disponer de un campo vectorial, cuyos vectores sean los valores de gravedad (o también funciona con los "up"). Sería como un bake. Eso sí, si el objeto es dinámico no se, quizás se pueda calcular frame a frame para resoluciones bajas.
#51
Recursos / [TUTORIAL] Crea tu propia carta 3D
Enero 24, 2020, 07:19:45 PM
Excelente!
 
Le quería entrar a los stencil hace rato, quizás ahora sea el momento.
 
 
 
Gracias!!
#52
Scripting / Tembleque al usar fisica
Enero 24, 2020, 07:17:47 PM
Cita de: Jhonatan00_00 date=1579869153¿de que forma actualizamos correctamente las físicas?,
   


Está en el post de más arriba. FixedUpdate, por las razones que mencioné antes.
 
Cita de: Jhonatan00_00 date=1579869153¿seria mejor con Time.fixedDeltaTime, con Time.frameCount?, ¿como lo haceis?.
   


Velocidad = Δ desplazamiento / Δ tiempo
 
Δ desplazamiento es la cantidad de desplazamiento que le tenés que agregar a tu objeto, es decir sería tu " + transform.forward * Velocidad * Time.deltatime ": Despejando:
 
Δ desplazamiento = Velocidad *  Δ tiempo
 
De ahí sale la forma esta (que se llama de "Euler"). Todo en realidad parte desde las derivadas, pero acá te manejas con pequeños incrementos, osea el tiempo de frame a frame (no el frame count). En el mundo Unity sería:
 
Δ desplazamiento = Velocidad *  dt
 
Y cual es el dt que debés usar? bueno, eso depende (y no tanto, ahora vas a ver) del método que uses:
 


  •    Si es Update Time.deltaTime te da el tiempo que tardó el último frame.


  •    Si es FixedUpdate (<--- es este) Time.fixedDeltaTime te da el tiempo que pasó en FIxedUpdates (generalmente coincide con "Project Settings/Time/Fixed step" (creo))


Pero, y si estás en FixedUpdate y llamás a Time.deltaTIme ¿que pasa?, nada, te devuelve lo mismo que Time.fixedDeltaTime ... yo siempre uso Time.deltaTime para todo y listo.
 
frameCount devuelte la cantidad de frames que pasaron, osea que no es un dt, no sirve.
 
Cita de: Jhonatan00_00 date=1579869153Por cierto, he observado que si tienes dos fuerzas distintas programadas (una para avanzar y otra si pulsas la tecla de saltar para que suba) y activas Interpolate una fuerza anula a la otra y no lo hace bien, en cuyo caso tienes que usar extrapolate.
   


Eso habría que ver el código, osea con "tener dos fuerzas programadas" no se entiende demasiado. Lo que sí se sabe es que se debe hacer una sola llamada a MovePosition por frame físico. --> https://docs.unity3d.com/ScriptReference/Rigidbody2D.MovePosition.html
 
It is important to understand that the actual position change will only occur during the next physics update therefore calling this method repeatedly without waiting for the next physics update will result in the last call being used. For this reason, it is recommended that it is called during the FixedUpdate callback.

Note: MovePosition is intended for use with kinematic rigidbodies.

 
 
#53
Offtopic / que precio debo ponerle a mi asset?
Enero 24, 2020, 02:01:13 AM
Cita de: gonzalitosk8 date=1579816119pueden orientarme sobre un precio fijo?
   


Hola, no soy un experto ni nada y además hace 1 año casi exacto que vendo assets, así que lo que digo agárralo con pinzas.
 
Lo primero que sí tenés que hacer (fuera del tema del precio) es unirte en el foro de Publishers del foro oficial. No recuerdo si necesitas publicar primero o solo con registrarte como publisher te dan el pase. La cuestión es que ahí se discuten este tipo de temas y más. Un topic estaba orientado exactamente a esto, y un developer de Unity dejó este video:
 


   
eature=oembed">

 
En definitiva no existe una respuesta 100% clara. El precio de algo (dentro de un contexto) acarrea la información de tu producto. Entra la cuestión de que somos seres caóticos y emocionales, y estamos dispuestos a comprar algo, no solo para usarlo, sino también para lucir y refregar en la cara lo que pagamos (o al menos creérnosla de que fue bueno, lo sea o no tanto).
 
Es difícil decirte $ X estando muy seguro (esto debido a que internamente no conozco tu asset, y creas o no, todo vale, no solo los features) pero puedo plantear algunas cuestiones que para mi son importantes (mmm ya me veo escribiendo un post largo ):
 
1 - Oferta/Demada + Tu toque: El primer error es suponer que el precio representa el esfuerzo detras. Si esto fuera así un asset complejo saldría un ojo de la cara. Como todo, es un balance entre oferta y demanda, pero también podés meter el "factor humano" en el medio. Esto va de la mano con el punto 2 (casi el método clásico de elección en el Asset store) --->
 
2 - Buscar assets similares: Esto puede ser beneficioso o no. A veces tenés que hacer la tuya y sobresalir con el precio. Basicamente le decís a quien te compra el producto "Soy mejor que el resto" (que dicho sea de paso es alguien que probablemente no tenga conocimiento del "resto"). Esto lo podés asociar a una "etiqueta" de precio (creo que así las llaman). Por ej, para el mundo de los juegos, si compras algo de $60 es un juego AAA (esto ya es como cultura general ya), entonces vos esperas un producto así. Buscá un asset similar y (como estás arrancando) cobralo (no se) 5 dolares menos ... esto va al punto 3 --->
 
3 - Futuros incrementos: ¿Cual es tu plan a futuro con el precio? pensas poner el asset a un precio final de entrada? o ir incrementando poco a poco? (una o dos veces el primer año). Quizás esto pueda usarse como estrategia también. El comprador solo se da cuenta de esto, no es necesario hacer un aviso.
 
4 - Más allá del contenido del asset, muchas veces lo que vale (y mucho) es:
 
4.1 Soporte: Responder mails, resolver bugs, etc. Atención en general, ser "profesional", saludar formalmente. Basicamente transmitir al cliente y al resto que están lidiando con alguien que se preocupa por ellos, no solo alguien que junto código y lo subió a la store para ganar dinerillo.
 
4.2 Documentación, manuales, referencias de API, todo esto te da un colchón impresionante. Evitar word, bloc de notas, y todas esas cosas medias cutres. Es muy útil saber redactar tu documentación y además presentarla bien.
 
4.3 Extras de todo tipo: página web propia, demos, redes sociales, contactos, en redes sociales y en el mismo foro de Unity.
 
5 - Código "PRO" (al menos a la vista jaja): Esto puede o no aplicarse a tu caso, si tenés código está bueno diseñarlo usando ciertos estándares, sobretodo para extenderlo, mejorarlo vos mismo y además brindar documentación de la API. No solo algo que haga un tarea y listo. EJ: Esto mueve a un objecto 5 unidades por segundo en una dirección:
 

 
Esto hace exactamente lo mismo, y además explica bien de que va cada campo y método, además de que permite personalizar el método (en esta caso una pavada) con una implementación propia haciendole un override:
 

 
6 - Metadata: A lo último pero muy importante también. Que és esto? videos, imagenes, Logos, etc. Tampoco es necesario pegar altas ediciones de video, ni ser un experto de Ilustrator, simplemente tener algo de gusto y un poco de sentido común.
 
 
 
En resumen, te sugiero que te vayas al punto 2. Empezá a buscar asset similares. Si pensas que a futuro lo vas a dejar mejor que no te importe cobrar más incluso si a la primera no vendés nada. Tené cuidado con poner algo a un precio y bajarlo porque no se vende, esto lo que transmite es falta de confianza. Tampoco pongas un precio exageradamente bajo porque lo vas a terminar subiendo mucho seguramente.
 
Tu asset se ve muy prometedor! La verdad que por lo técnico soy un queso diciendote vale tanto. También te diría que mantengas ese "look Unity" y no metas demasiados colores y cosas a la UI , basicamente usá estilos compatibles con Unity (Button, Box, HelpBox, etc). No hagas lo que hizo el autor de Aura2 (En las reviews lo matan con esto).
 
Otra, andate a los UI Element si podés, este año va a ser el año del pase, más de la mitad de la gente que usa el Asset store está en 2019! (está en el foro de publishers). Y además 2020 trae (supuestamente) el nuevo Input System. Así que para nosotros que vendemos assets es un momento clave de transición.
 
(jaja terminó el magapost y no te dije ni un valor ... ponele $15 dolares a ver que pasa , de última le subís)
 
 
 
Saludos
#54
Scripting / Tembleque al usar fisica
Enero 23, 2020, 10:40:04 PM
Cita de: Jhonatan00_00 date=1579787888Si uno mira los manuales y los tutoriales de Internet se da cuenta de que por ejemplo para hacer a un personaje saltar usan rigidbody.velocity, mientras que para hacer que avance hacia delante usan rigidbody.AddForce y como estas fuerzas a veces son opuestas si no están bien montadas causan tembleques o dan problemas
   

Cita de: Jhonatan00_00 date=1579787888- ¿Que fuerzas existen para aplicar al rigidbody y para que casos se usan?, aunque sea explicarlo solo por encima y no entrando en demasiado detalle, ¿para que avance un personaje solo tenemos rigidbody.AddForce?.
   


En general no existen reglas, podés hacer lo que quieras, todo dependerá del tipo de resultado deseado.
 
"Si se mueve y te gusta el resultado, está bien" - Lightbug, enero de 2020.
 
Por ejemplo: asignando la velocidad de manera absoluta te da algo super exacto, basicamente querés que el cuerpo vaya a tal lugar y lo tenés. Todavía tenés alguna que otra cosita que te puede modificar el comportamiento (drag, angular drag, materiales físicos, etc) pero tenés trucos para todo esto.
 
Si por el contrario querés que la simulación sea 100% real life no fake entonces asignar la velocidad de manera absoluta (lo remarco de nuevo) es lo peor que podés hacer.
 
En este mundo tenés similaridades con el cálculo diferencial. Disponés de "órdenes de control" sobre la posición y rotación:
 


  •    orden 0: (sin derivar): Posición y rotación -> basicamente personajes kinemáticos


  •    order 1: (derivando lo anterior) -> velocidad lineal y velocidad angular -> rigidbodies dinámicos


  •    orden 2: (resultado de derivando lo anterior) -> Fuerza y Torque. -> rigidbodies dinámicos


Mientras mayor es el orden tenés menor control. Notá que para el orden 2 no podés anular la velocidad de golpe, vas a obtener un resultado más realista (no necesariamente un mejor resultado).
 
────────────────────────────────────────────────────────────────────────────
 
Por ej para el orden 2 es muy útil utilizar controladores PID para realizar movimientos algo precisos empleando fuerzas.
 
En resumen, tenés una entrada de referencia con velocidad = v (puede ser cualquier valor), esta señal pasa por unos bloques de compensación (el PID) luego la velocidad de salida se realimenta a la entrada y se calcula la diferencia entre este resultado y la velocidad de set v. Esto finalmente reingresa al loop y así forever. La velocidad de salida tenderá al valor de set, esto por las características del PID, también dependerá mucho de la elección de los parámetros Kp Ki y Kd.
 
Aca un vid con un ejemplo de posición:
 


   
eature=oembed">

 
Todo esto es teoría de control, el tema es bastante complejo como para entenderlo en un post. Hay mucho material muy interesante.
#55
Cita de: Jhonatan00_00 date=1579683560¿Por que hay que poner que si Diferencia_Angulos es menor a 0 se invierta?, porque la función Math.DeltaAngle da ángulos negativos y no queremos eso... Después con el dato de Diferencia_Angulos podemos hacer que si esa diferencia no es menor a 45º, 90º o lo que queramos que el personaje no empiece a avanzar y funciona, pero no es tan profesional como me gustaria que fuese y por eso sigo calentándome la cabeza.
   


Ah lindo método, no lo conocía, me sirve! jaja
 
Cita de: Jhonatan00_00 date=1579683560Esta va a ser la solución, el problema es, ¿como creo en Unity una fórmula para convertir esa diferencia de ángulos en un valor de 0 a 1?, porque no es tan facil como poner Clamp(diff, 0, 20)/ 20.
   


La fórmula esa te devuelve un valor entre 0 a 1, pero debés asignar ese valor a algo, por si sola no hace nada:
 

public float valor;
//...
// si el valor es <0 => Mathf.Clamp =0
// si es >max => Mathf.Clamp = max  
// Se le asigna el valor limitado a "valorClampeado"
float valorClampeado = Mathf.Clamp( valor , 0 , max );
// si el valorClampeado es max => valorNormalizado = 1f
// si el valorClampeado es 0 => valorNormalizado = 0f
float valorNormalizado = valorClampeado / max;

 
 
#56
Arte / Bump Mapping Cambiar Geometria (SOLUCIONADO)
Enero 16, 2020, 10:21:49 PM
Cita de: Jhonatan00_00 date=1579208567la versión de Unity que estoy usando que es la 4.7.2
   


 hombre actualiza, esa la usaba yo en 2012 creo jajaj
 
Cita de: Jhonatan00_00 date=1579208567El Normal Map es una textura que añade detalle dependiendo de la dirección de la luz, creando brillos y sombras artificiales, pero no modifica la geometría del objeto, mientras que el Bump Mapping remodela la geometria añadiendo pliegues, etc (subo una imagen con un ejemplo).
   


No, bump mapping y normal mapping producen algo muy parecido, ambos son efectos "fake" que no modifican la geometría. La diferencia es que los Normal maps usan RGB (3 Bytes por pixel) para representar una normal (Vector3), cuando el bump usa escala de grises (1 Byte por pixel) para esto. Con el normal podés meter una normal inclinada vs una normal perpendicular del bumb (o por lo menos así lo entendí toda la vida). Hoy en día casi que se usa Normal maps o por lo menos es lo que más se ve, estos al estar representados en 3 canales podés expresar 3 componentes <x,y,z>.
 
Probablemente te hayas confundido con height maps vs normal maps (?).
 
Cita de: Jhonatan00_00 date=1579208567- ¿Como puedo crear algo así en Unity?.
   


No estoy 100% seguro, pero en su momento recuerdo que debías tener hardware compatible con DX11, habilitar tesselation, usar un material con "height map" y meterle el "height map" deseado.
 
Aca te dejo un vid con Unity 4 + tesselation;
 
https://www.youtube.com/watch?v=YlR69pXb0oY
 
 
 
Saludos
#57
Scripting / incremento con while
Enero 15, 2020, 12:52:30 AM
Cita de: nomoregames date=1579031893Sip
   
   
      (joder me ha dado un huelco el corazón, siempre que apareces en alguno de mis posts me arreglas la vida)
   


Jajaja, bueno me imagino que estás haciendo esto dentro de una corrutina. Quizás podrías subir el código entero así se ve mejor la cosa.
 
 
#58
Scripting / incremento con while
Enero 14, 2020, 07:34:49 PM
Estás usando el Input.GetMouseButton( 1 ) no??
#59
Scripting / Tembleque al usar fisica
Enero 14, 2020, 05:37:16 PM
Cita de: totemalf date=1579007792Resumiendo, mi pregunta es si es un precio a pagar por usar el motor de fisica o es que a mi me esta pasando algo raro
   


No, debería ir todo super fluido.
 
Cita de: totemalf date=1579007792Resumiendo, mi pregunta es si es un precio a pagar por usar el motor de fisica o es que a mi me esta pasando algo raro. Por cierto, estoy usando la ultima version alpha de unity 2020.
   


Cómo es que estás moviendo el objeto?, necesitamos código para poder contestarte con certeza, sobretodo con estos temas que son extremadamente delicados. Siempre ojo con una alpha. Dicho esto, te tiro algunos datos sueltos que quizás te ayuden a entender un poco más este mundo.
 
Dos mundos:
 


  1.    Transform: transform.position, transform.Translate, transform.Rotate , etc...


  2.    Físicas: rb.position, rb.MovePosition(...), rb.velocity, rb.AddForce( .. ) , etc ...


Nunca nunca nunca mezclar estos mundos, por ej teniendo un Rb dinámico y moverlo usarlo Transflate. Existen casos y casos, en general no es recomendado.
 
Yo me manejo 100% con rigibody en FixedUpdate, para mi Transform se usa para leer cosas muy específicas, o para cuestiones de Gizmos y demás, para el resto lo elimino de mis scripts (por lo menos los evito si necesito un comportamiento físico).
 
 
 
Funcionamiento de las físicas (muy por arriba):
 
El truco está en entender cuando las físicas hacen lo suyo y qué es lo que hacen. Basicamente cuando se da un step de simulación se realizan dos cosas (muy resumido):
 


  1.    los physics queries (raycast, spherecast, etc)


  2.    se determinan las velocidades de los rigidbodies en base a choques, materiales, etc.


Una vez que esto termina se hace un "Sync", esto basicamente actualiza el componente Transform (RB -> T), que determinara visualmente donde estará el objecto. Gracias a esto es que sin tocar el Transform vos podés ver los resultados en pantalla. Que dicho sea de paso, el motor lee el componente Transform para mostrar las cosas en pantalla, todo lo visual está directamente relacionado a este (las físicas pueden recalcular todo de arriba a abajo y nada se va a actualizar en pantalla).
 
AutoSync:
 
Si tu objeto es kinematico y lo movés usando Transform es probable que para versiones viejas de Unity no hayas notado la diferencia con moverlo "legalmente" usando físicas. Probablemente todo haya resultado fluido, esto es porque antes se usaba "autoSync" por defecto. Este autoSync lo que hacía era detectar un cambio en un transform y recalcular toda la parte de las físicas, actualizando el Collider, la pos y rot del rigidbody. Osea que estaba todo perfectamente sincronizado (T -> RB). Desde ya que esto demandaba mayor procesamiento. Hoy en día este autoSync está desactivado por defecto, demandando mayor preocupación por parte del programador a la hora de mover un rigidbody, o de realizar simples queries.
 
Interpolación:
 
Un poco más complicado de entender, pero similar a lo anterior. Por qué usar interpolación? si movés un rigidbody usando FixedUpdate (como debe de ser) vas a notar que los cambios pasan a 50 fps por defecto (probablemente no tan notable,). Si esta tasa de refresco fuera cada vez menor los cambios se harían más y más notables. Como se soluciona? interpolando estos valores, ya que el Transform está más al pedo que bocina de avión, se lo usa para generar visualmente (recordar lo que dije más arriba) un resultado, mientras las físicas laburan. En el mundo transform se van a generar posiciones y/o rotaciones intermedias, es decir, va a interpolar las pos y rots para generar visualmente un resultado.Con velocity pasa lo mismo si tenés interpolación activada.
 
MovePosition sirve si tenés un RB Kinemático con interpolación activada. Un dato extra: Si llamás a MovePosition estando en la pos A, y le decís "movete a B" ( rb.MovePosition(posB) ), vas a notar que la rb.position no se actualiza para nada (es igual a posA). Esto es porque MovePosition se actualiza después del step físico.
 
FixedUpdate:
 
El step físico (que hace todo lo de arriba y más) ocurre después de cada FixedUpdate, entonces si vas a mover algo usando físicas (ya sea un Rb dinámico o kinemático) lo lógico es hacerlo en FixedUpdate y no en Update.
 
 
 
Espero que sirva de algo, quizás estás metiendo la pata en alguno de esos puntos, o quizás en alguno que no mencioné. De todos modos sería útil si subieras el código que utilizas.
 
 
 
Saludos
#60
Offtopic / Dennis Gustafsson, un crack
Enero 13, 2020, 01:11:22 AM
Cita de: francoe1 date=1578782052Con esto se llevó mi corazón jajaja
   


Jaja posta, yo dije exactamente lo mismo.
 
Cita de: Alex date=1578872138Destrucción combinada con buenos gráficos? estilo voxel? Y recomendada por lightbug?
   
   
      Dónde firmo para pagarlo hasta a plazos jaja
   


Jajaja firme aquí:
 

Cita de: J Montes date=1578604667Gracias por el post con todos los videos :).
   


De nada!