SchultzGames
Para tirar dúvidas, crie um tópico especifico na área "Dúvidas em Geral" e aguarde ser respondido. Evite comentar em tópicos não relacionados a sua dúvida :D
TÓPICOS RECENTES:
Tópico:
Postado em:
Postado por:
Compilando pra android
CHECKPOINT PONTO DE SALVAMENTO
[RESOLVIDO] Por que o NavMesh não está gerando um destino?
[TUTORIAL] Third Person Shooter
[RESOLVIDO] Aumentar um valor quando próximo do HitPoint
Erro No Unity
Bora entrar no Discord.. Tirando Duvidas Online..
Procuro Programador para jogo baseado em Harvest Moon - Unity (3D)
[RESOLVIDO] Unity - Erro ao Mudar de Resolução
[____TÓPICO LIVRE____] FALE O QUE QUISER (Parte 2)
[TUTORIAL] Script simples para CAMA ELÁSTICA
[RESOLVIDO] Cama elastica e ventuinha que lança pra cima
[RESOLVIDO] Unity não está aceitando imagens
Ajuda com orientação de rotação de objeto
Recompensa diária
Herança Classes
[Divulgação] Projeto The World of Child
Como Criar uma nova classe com as mesmas variaveis?
Como recriar esta fisica?
[RESOLVIDO] problema movimentação horinzontal
Exclusão de arquivos desnecessários da Photon Network (PUN)
luz
Como desativar o componente IMAGE e ativar automaticamente depois de certo tempo
Alguem sabe como resolver esse problema? AI nao procurar ela mesma
[TUTORIAL] Barra de VIDA / HP contínua
Compilação pra android unity 3d
[____APOIE O FÓRUM E O CANAL E GANHE RECOMPENSAS____]
[____ADMINISTRAÇÃO____] PRECISO DE AJUDA [DICA PARA SER AJUDADO]
[___COMO UTILIZAR O FÓRUM___] Principais botões e suas funções
[TUTORIAL] Mover e rotacionar objeto em relação a posição do MOUSE
Error depois de copilar para Android?
[TUTORIAL] 42 ÓTIMAS DICAS DE OTIMIZAÇÃO PARA JOGOS MOBILE (Android)
Inputfield 3D: alguém sabe como fazer? algum tutorial? ideia pra começar?
Rotacionar Y-axis Atraves
AnimatorOverrideController
Ajuda com Script para IA
Jogo Adaptativo a Tamanho de Telas
[PROJETO MOBILE] Defeat the Illuminatis
Curso Básico de Photoshop
[RESOLVIDO] Pra que serve o F?
[Projeto] Xuel The glory | Testem e avaliem o meu jogo medieval :3
Encriptar player prefs
COMPETIÇÃO - Melhor Jogo Indie
Ajuda em Votação para o GameJAM+
Remover limite de VSync no Android
Volante GameObject girar junto com O grafico UI Android
[TUTORIAL] Inserindo animações com Mixamo
[RESOLVIDO] Problema de renderização
[ Formação de Equipe ] Para Desenvolvimento de Jogo Mobile/PC
Streering Behaviors C#
[TUTORIAL] Salvar SCORE e substituir caso faça mais pontos.
Participe da Game Jam - Jaaj do canal Amdré Young!
Como criar um ranking online na Unity usando a PlayFab e o Facebook?
Armário Escolar (School Locker) by RafaelSquid1
Duas duvidas sobre o bake no blender
[RESOLVIDO] Pointer Influence
[RESOLVIDO] Saber o lado de um círculo toca em um objeto.
Animar collider
[TUTORIAL] Aprenda C# - Unity 3D
[TUTORIAL] AI Enemy ( Jogos de terror )
Troca de personagem em jogo 2d
Ficou legal? Minha primeira modelagem
Alguém Afim de Jogar e testar Survival Online? PC e Mobail...
[RESOLVIDO] Como fazer uma textura com elevações?
Como criar sombra em objeto transparente?
Sistema de Entidades e Componentes(ECS)
Gostaria que opinassem sobre esse cenario que fiz
Como salvar objetos que tenham uma Tag especifica (save/load)
Care Box - Disponível na Play Store
Como utilizar a Unity em equipe
Problema para atualizar App na Apple Store Itunes Connect
Command 888
Buscar o índice de um array que está dentro de outro array (JavaScript)
Problema de Compilação Na Unity
Como fazer um sistema de IK para os pés ?
Porque a luz buga na aba Game e quando eu faço a build fica normal
[RESOLVIDO] Sincronizar uma bool que não esta no player?
(Formação De Equipe) Favela Killer
Configurar NPCs
Sistema de spawn de monstros multiplayer
Como juntar animações do mixamo
Rank usando o facebook para JOGO QUIZ
Menu de selecionar carros e pistas estilo Forza
Controle Estilo GTA
Como usar o bake em uma situação como essa ?
[RESOLVIDO] Instanciar um objeto com Raycast?
[RESOLVIDO] Efeito cromado não aplica no mesh
[RESOLVIDO] Quero tirar uma dúvida!!
Opacidade / Transparência e Novas Ideias
Cores invertidas/Estranhas no PC
[RESOLVIDO] Como mudar o scale de um sprite renderer????
[TUTORIAL] Câmera seguir o mouse em 2D, com limite de distancia ao Jogador
Portas estilo gta 5
Movimento Snake Cobra
NEW FANTASY PACKS! Download Now!
Corcle (Mobile) - Um jogo simples com um nome estranho.
Como fazer este estilo no Unity 3d?
Problema do RIG do Pé Esquerdo - Animação Mixamo
[TUTORIAL] Câmera para jogo 2D ou 2.5D.
Hoje à(s) 12:10 am
Ontem à(s) 7:30 pm
Ontem à(s) 3:30 pm
Ontem à(s) 3:11 pm
Ontem à(s) 2:59 pm
Ontem à(s) 1:32 pm
Ontem à(s) 12:54 pm
Ter Ago 14, 2018 8:08 pm
Ter Ago 14, 2018 3:15 pm
Ter Ago 14, 2018 10:07 am
Seg Ago 13, 2018 9:46 pm
Seg Ago 13, 2018 8:57 pm
Seg Ago 13, 2018 4:52 pm
Seg Ago 13, 2018 10:09 am
Seg Ago 13, 2018 9:17 am
Seg Ago 13, 2018 9:05 am
Seg Ago 13, 2018 8:50 am
Dom Ago 12, 2018 10:53 pm
Dom Ago 12, 2018 4:43 pm
Dom Ago 12, 2018 4:15 pm
Dom Ago 12, 2018 3:47 pm
Dom Ago 12, 2018 3:07 pm
Sab Ago 11, 2018 4:02 pm
Sab Ago 11, 2018 11:13 am
Sex Ago 10, 2018 7:37 pm
Sex Ago 10, 2018 12:00 pm
Qui Ago 09, 2018 4:27 pm
Qui Ago 09, 2018 4:26 pm
Qui Ago 09, 2018 4:26 pm
Qui Ago 09, 2018 3:52 pm
Qui Ago 09, 2018 12:52 pm
Qui Ago 09, 2018 1:21 am
Qui Ago 09, 2018 1:17 am
Qui Ago 09, 2018 1:08 am
Qua Ago 08, 2018 11:57 pm
Qua Ago 08, 2018 10:59 pm
Qua Ago 08, 2018 8:17 pm
Qua Ago 08, 2018 8:05 pm
Qua Ago 08, 2018 7:35 pm
Qua Ago 08, 2018 6:00 pm
Qua Ago 08, 2018 3:14 pm
Qua Ago 08, 2018 11:54 am
Ter Ago 07, 2018 11:34 pm
Ter Ago 07, 2018 9:55 pm
Ter Ago 07, 2018 7:28 pm
Ter Ago 07, 2018 7:19 pm
Ter Ago 07, 2018 6:58 pm
Ter Ago 07, 2018 9:57 am
Ter Ago 07, 2018 1:20 am
Seg Ago 06, 2018 7:36 pm
Seg Ago 06, 2018 7:29 pm
Dom Ago 05, 2018 11:59 pm
Dom Ago 05, 2018 1:29 pm
Dom Ago 05, 2018 9:34 am
Sab Ago 04, 2018 3:09 pm
Sab Ago 04, 2018 11:47 am
Sab Ago 04, 2018 10:59 am
Sab Ago 04, 2018 9:23 am
Sab Ago 04, 2018 12:43 am
Sex Ago 03, 2018 11:43 pm
Sex Ago 03, 2018 11:38 pm
Sex Ago 03, 2018 10:21 pm
Sex Ago 03, 2018 10:14 pm
Sex Ago 03, 2018 8:37 pm
Sex Ago 03, 2018 5:26 pm
Sex Ago 03, 2018 4:41 pm
Sex Ago 03, 2018 12:35 pm
Sex Ago 03, 2018 12:24 pm
Qui Ago 02, 2018 10:33 pm
Qui Ago 02, 2018 8:31 pm
Qui Ago 02, 2018 8:10 pm
Qui Ago 02, 2018 5:35 pm
Qui Ago 02, 2018 5:01 pm
Qui Ago 02, 2018 4:53 pm
Qua Ago 01, 2018 9:45 pm
Qua Ago 01, 2018 7:44 pm
Qua Ago 01, 2018 5:40 pm
Qua Ago 01, 2018 4:52 pm
Qua Ago 01, 2018 12:02 pm
Qua Ago 01, 2018 8:51 am
Qua Ago 01, 2018 8:33 am
Ter Jul 31, 2018 8:00 pm
Ter Jul 31, 2018 6:35 pm
Ter Jul 31, 2018 5:09 pm
Ter Jul 31, 2018 2:39 pm
Seg Jul 30, 2018 11:21 pm
Seg Jul 30, 2018 11:06 pm
Seg Jul 30, 2018 10:35 pm
Seg Jul 30, 2018 9:17 pm
Seg Jul 30, 2018 7:54 pm
Seg Jul 30, 2018 7:53 pm
Seg Jul 30, 2018 7:49 pm
Seg Jul 30, 2018 4:29 pm
Seg Jul 30, 2018 3:09 pm
Seg Jul 30, 2018 2:06 pm
Seg Jul 30, 2018 2:02 pm
Seg Jul 30, 2018 12:57 pm
Seg Jul 30, 2018 11:15 am
Seg Jul 30, 2018 10:57 am
niao
NotoriousDev
loganout
Phph09
NotoriousDev
NotoriousDev
loganout
NKKF
Magnatah
dstaroski
FelipeSouza11
paulo.costa0194
alisonzinhod
dstaroski
dstaroski
dstaroski
dstaroski
luKkaSs
dazentt55
NotoriousDev
NotoriousDev
diegopds
Dom3000
Dom3000
Badstane
Callyde Jr
FelipeSouza11
FelipeSouza11
FelipeSouza11
Unidade3d5
Callyde Jr
MarcosSchultz
MarcosSchultz
MarcosSchultz
Madson
Unidade3d5
Magnatah
dstaroski
dstaroski
lesgoy
zeca urubu
Ezequiel286
Gray_14
C3RB3RUS
NKKF
Gabryellx007
Phph09
sneffetsd
lucas85235
MarcosSchultz
MarcosSchultz
QueriaStarMorto
Rayllander
Callyde Jr
TioUV
NKKF
NKKF
gurgelg752
MarcosSchultz
MarcosSchultz
MarcosSchultz
guimaraf
fecirineu
LucioHenrique890
lesgoy
MarcosSchultz
Callyde Jr
Edw223
RafaelSquid1
QueriaStarMorto
natanael.olimpio
Callyde Jr
MarcosSchultz
MarcosSchultz
ruanzikaad
diegopds
Extreme Craft
zeca urubu
Daniel Dória
artplayer
Isabela
Rayllander
edugamer69
MarcosSchultz
TioUV
AdrianJps
TioUV
JohnVitor
MarcosSchultz
lesgoy
Flávio
MarcosSchultz
MarcosSchultz
Flávio
dstaroski
dstaroski
RafaelSquid1
osiasbezerra
LucioHenrique890

Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Ir em baixo

DÚVIDA Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Leetz1k em Dom Abr 22, 2018 10:37 pm

Boa noite,estou com problemas na iluminação da minha lanterna,fiz uma luz volumétrica,porém quando posiciono ela na frente da 
lanterna ,ela fica estranha,quando me aproximo de objetos,ou até mesmo portas,paredes ela some,como se estivesse atravessando.
Alguém pode me ajudar?

Leetz1k
Iniciante
Iniciante

PONTOS : 547
REPUTAÇÃO : 0
Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Phph09 em Seg Abr 23, 2018 6:29 pm

Poderia gravar um video do seu problema?
E postar os seus scripts?
avatar
Phph09
ProgramadorMaster

Masculino PONTOS : 1512
REPUTAÇÃO : 228
Idade : 13
Áreas de atuação :

Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Leetz1k em Seg Abr 23, 2018 6:53 pm

Código:
Esse é o script da luz ,eu uso uma spotlight

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PropriedadesLuzLanterna : MonoBehaviour {
    [Header("Observação")]
    public Texture[] TexturaBateria;
    public int numero;
    private AudioSource som;
    private Sons bSom;
    public static float tempoTotal =250; // TEMPO QUE Q A BATERIA COMEÇA A CAIR,PODE SER ALTERADO QUALQUER COISA.
    public float tempoMinimo = 20;
    public int pilhaASerTexturizada;
    public float anguloDaLuz = 45;
    public float distanciaDaLuz = 5;
    public float intensidade = 3;
    public float reducaoForcaLuz = 50;
    public float CargaDaBateria;
    //public bool podeLigar;
    public static float TempoTotalInicial;
    public float anguloMaximo, anguloMinimo, intensidadeMaxima, intensidadeMinima, distanciaMax, distanciaMin;
    [Space (15)]
    [Header("Variavel de som")]
    public AudioClip SManivela;
    void Start()
    {
        //GetComponent<Light>().enabled = true;
        TempoTotalInicial = tempoTotal;
        //podeLigar = true;
        numero = Mathf.RoundToInt(tempoTotal) / TexturaBateria.Length;
        bSom = GameObject.FindGameObjectWithTag("GameController").GetComponent<Sons>();
        som = GetComponent<AudioSource>();
        som.clip = bSom.LanternaGirarmanivela;
        
    }
    void Update()
    {
        if (GetComponent<Light>().enabled == true )
        {
            tempoTotal -= Time.deltaTime;
        }
      if (Input.GetKeyDown("f"))
        {
            if (PropriedadesLuzLanterna.tempoTotal + CargaDaBateria <= PropriedadesLuzLanterna.TempoTotalInicial)
            {

                PropriedadesLuzLanterna.tempoTotal = PropriedadesLuzLanterna.tempoTotal + CargaDaBateria +3;
                //GetComponent                if (!som.isPlaying) {
                    som.Play();
                }
            }
            else if (PropriedadesLuzLanterna.tempoTotal + CargaDaBateria >= PropriedadesLuzLanterna.TempoTotalInicial)
            {
                PropriedadesLuzLanterna.tempoTotal = PropriedadesLuzLanterna.TempoTotalInicial +3;
                // GetComponent<Light>().enabled = true;
                if (!som.isPlaying)
                {
                    som.Play();
                }
            }
        }
        if (tempoTotal <= tempoMinimo)
        {
            som.PlayOneShot(bSom.LanternaBateriaAcaba);

            
            // GetComponent            // podeLigar = false;
        }
        if (tempoTotal >= tempoMinimo)
        {
            //podeLigar = true;
        }
        if (tempoTotal >= TempoTotalInicial)
        {
            tempoTotal = TempoTotalInicial;
        }
        GetComponent<Light>().spotAngle = anguloDaLuz * tempoTotal / reducaoForcaLuz;
        GetComponent<Light>().range = distanciaDaLuz * tempoTotal / reducaoForcaLuz;
        GetComponent<Light>().intensity = intensidade * tempoTotal / reducaoForcaLuz / 2;
        pilhaASerTexturizada = Mathf.FloorToInt(tempoTotal / numero);
        //==========================VALORES MAXIMOS E MINIMOS=============================
        if (GetComponent<Light>().spotAngle >= anguloMaximo)
        {
            GetComponent<Light>().spotAngle = anguloMaximo;
        }
        if (GetComponent<Light>().spotAngle <= anguloMinimo)
        {
            GetComponent        }
        //========================================
        if (GetComponent<Light>().range >= distanciaMax)
        {
            GetComponent<Light>().range = distanciaMax;
        }
        if (GetComponent<Light>().range <= distanciaMin)
        {
            GetComponent        }
        //========================================
        if (GetComponent<Light>().intensity >= intensidadeMaxima)
        {
            GetComponent<Light>().intensity = intensidadeMaxima;
        }
        if (GetComponent<Light>().intensity <= intensidadeMinima)
        {
            GetComponent        }
    }
    void OnGUI()
    {
        GUI.DrawTexture (new Rect (Screen.width / 2 + Screen.width / 2.3f, Screen.height / 2 - Screen.height / 4, Screen.width / 25, Screen.height / 10), TexturaBateria[pilhaASerTexturizada]);
    }
}

Leetz1k
Iniciante
Iniciante

PONTOS : 547
REPUTAÇÃO : 0
Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Leetz1k em Seg Abr 23, 2018 7:03 pm

Código:
using UnityEngine;
using System.Collections;
using UnityEngine.Rendering;
using System;

[RequireComponent(typeof(Light))]
public class VolumetricLight : MonoBehaviour
{
    public event Action<VolumetricLightRenderer, VolumetricLight, CommandBuffer, Matrix4x4> CustomRenderEvent;

    private Light _light;
    private Material _material;
    private CommandBuffer _commandBuffer;
    private CommandBuffer _cascadeShadowCommandBuffer;

    [Range(1, 64)]
    public int SampleCount = 12;
    [Range(0.0f, 1.0f)]
    public float ScatteringCoef = 0.1f;
    [Range(0.0f, 0.1f)]
    public float ExtinctionCoef = 0.01f;
    [Range(0.0f, 1.0f)]
    public float SkyboxExtinctionCoef = 0.9f;
    [Range(0.0f, 0.999f)]
    public float MieG = 0.1f;
    public bool HeightFog = false;
    [Range(0, 0.5f)]
    public float HeightScale = 0.10f;
    public float GroundLevel = 0;
    public bool Noise = false;
    public float NoiseScale = 0.015f;
    public float NoiseIntensity = 1.0f;
    public float NoiseIntensityOffset = 0.3f;
    public Vector2 NoiseVelocity = new Vector2(3.0f, 3.0f);

    [Tooltip("")]   
    public float MaxRayLength = 400.0f;   

    public Light Light { get { return _light; } }
    public Material VolumetricMaterial { get { return _material; } }
   
    private Vector4[] _frustumCorners = new Vector4[4];

    private bool _reversedZ = false;

    /// <summary>
    ///
    /// </summary>
    void Start()
    {
#if UNITY_5_5_OR_NEWER
        if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11 || SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D12 ||
            SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal || SystemInfo.graphicsDeviceType == GraphicsDeviceType.PlayStation4 ||
            SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan || SystemInfo.graphicsDeviceType == GraphicsDeviceType.XboxOne)
        {
            _reversedZ = true;
        }
#endif

        _commandBuffer = new CommandBuffer();
        _commandBuffer.name = "Light Command Buffer";

        _cascadeShadowCommandBuffer = new CommandBuffer();
        _cascadeShadowCommandBuffer.name = "Dir Light Command Buffer";
        _cascadeShadowCommandBuffer.SetGlobalTexture("_CascadeShadowMapTexture", new UnityEngine.Rendering.RenderTargetIdentifier(UnityEngine.Rendering.BuiltinRenderTextureType.CurrentActive));

        _light = GetComponent<Light>();
        http://_light.RemoveAllCommandBuffers();
        if(_light.type == LightType.Directional)
        {
            _light.AddCommandBuffer(LightEvent.BeforeScreenspaceMask, _commandBuffer);
            _light.AddCommandBuffer(LightEvent.AfterShadowMap, _cascadeShadowCommandBuffer);
               
        }
        else
            _light.AddCommandBuffer(LightEvent.AfterShadowMap, _commandBuffer);

        Shader shader = Shader.Find("Sandbox/VolumetricLight");
        if (shader == null)
            throw new Exception("Critical Error: \"Sandbox/VolumetricLight\" shader is missing. Make sure it is included in \"Always Included Shaders\" in ProjectSettings/Graphics.");
        _material = new Material(shader); // new Material(VolumetricLightRenderer.GetLightMaterial());
    }

    /// <summary>
    ///
    /// </summary>
    void OnEnable()
    {
        VolumetricLightRenderer.PreRenderEvent += VolumetricLightRenderer_PreRenderEvent;
    }

    /// <summary>
    ///
    /// </summary>
    void OnDisable()
    {
        VolumetricLightRenderer.PreRenderEvent -= VolumetricLightRenderer_PreRenderEvent;
    }

    /// <summary>
    ///
    /// </summary>
    public void OnDestroy()
    {       
        Destroy(_material);
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="renderer"></param>
    /// <param name="viewProj"></param>
    private void VolumetricLightRenderer_PreRenderEvent(VolumetricLightRenderer renderer, Matrix4x4 viewProj)
    {
        if (!_light.gameObject.activeInHierarchy || _light.enabled == false)
            return;

        _material.SetVector("_CameraForward", Camera.current.transform.forward);

        _material.SetInt("_SampleCount", SampleCount);
        _material.SetVector("_NoiseVelocity", new Vector4(NoiseVelocity.x, NoiseVelocity.y) * NoiseScale);
        _material.SetVector("_NoiseData", new Vector4(NoiseScale, NoiseIntensity, NoiseIntensityOffset));
        _material.SetVector("_MieG", new Vector4(1 - (MieG * MieG), 1 + (MieG * MieG), 2 * MieG, 1.0f / (4.0f * Mathf.PI)));
        _material.SetVector("_VolumetricLight", new Vector4(ScatteringCoef, ExtinctionCoef, _light.range, 1.0f - SkyboxExtinctionCoef));

        _material.SetTexture("_CameraDepthTexture", renderer.GetVolumeLightDepthBuffer());
       
        //if (renderer.Resolution == VolumetricLightRenderer.VolumtericResolution.Full)
        {
            http://_material.SetFloat("_ZTest", (int)UnityEngine.Rendering.CompareFunction.LessEqual);
            http://_material.DisableKeyword("MANUAL_ZTEST");           
        }
        //else
        {
            _material.SetFloat("_ZTest", (int)UnityEngine.Rendering.CompareFunction.Always);           
            // downsampled light buffer can't use native zbuffer for ztest, try to perform ztest in pixel shader to avoid ray marching for occulded geometry
            http://_material.EnableKeyword("MANUAL_ZTEST");
        }

        if (HeightFog)
        {
            _material.EnableKeyword("HEIGHT_FOG");

            _material.SetVector("_HeightFog", new Vector4(GroundLevel, HeightScale));
        }
        else
        {
            _material.DisableKeyword("HEIGHT_FOG");
        }

        if(_light.type == LightType.Point)
        {
            SetupPointLight(renderer, viewProj);
        }
        else if(_light.type == LightType.Spot)
        {
            SetupSpotLight(renderer, viewProj);
        }
        else if (_light.type == LightType.Directional)
        {
            SetupDirectionalLight(renderer, viewProj);
        }
    }

    void Update()
    {
        _commandBuffer.Clear();
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="renderer"></param>
    /// <param name="viewProj"></param>
    private void SetupPointLight(VolumetricLightRenderer renderer, Matrix4x4 viewProj)
    {
        int pass = 0;
        if (!IsCameraInPointLightBounds())
            pass = 2;

        _material.SetPass(pass);

        Mesh mesh = VolumetricLightRenderer.GetPointLightMesh();
       
        float scale = _light.range * 2.0f;
        Matrix4x4 world = Matrix4x4.TRS(transform.position, _light.transform.rotation, new Vector3(scale, scale, scale));

        _material.SetMatrix("_WorldViewProj", viewProj * world);
        _material.SetMatrix("_WorldView", Camera.current.worldToCameraMatrix * world);

        if (Noise)
            _material.EnableKeyword("NOISE");
        else
            _material.DisableKeyword("NOISE");

        _material.SetVector("_LightPos", new Vector4(_light.transform.position.x, _light.transform.position.y, _light.transform.position.z, 1.0f / (_light.range * _light.range)));
        _material.SetColor("_LightColor", _light.color * _light.intensity);

        if (_light.cookie == null)
        {
            _material.EnableKeyword("POINT");
            _material.DisableKeyword("POINT_COOKIE");
        }
        else
        {
            Matrix4x4 view = Matrix4x4.TRS(_light.transform.position, _light.transform.rotation, Vector3.one).inverse;
            _material.SetMatrix("_MyLightMatrix0", view);

            _material.EnableKeyword("POINT_COOKIE");
            _material.DisableKeyword("POINT");
           
            _material.SetTexture("_LightTexture0", _light.cookie);
        }

        bool forceShadowsOff = false;
        if ((_light.transform.position - Camera.current.transform.position).magnitude >= QualitySettings.shadowDistance)
            forceShadowsOff = true;

        if (_light.shadows != LightShadows.None && forceShadowsOff == false)
        {
            _material.EnableKeyword("SHADOWS_CUBE");
            _commandBuffer.SetGlobalTexture("_ShadowMapTexture", BuiltinRenderTextureType.CurrentActive);
            _commandBuffer.SetRenderTarget(renderer.GetVolumeLightBuffer());

            _commandBuffer.DrawMesh(mesh, world, _material, 0, pass);

            if (CustomRenderEvent != null)
                CustomRenderEvent(renderer, this, _commandBuffer, viewProj);           
        }
        else
        {
            _material.DisableKeyword("SHADOWS_CUBE");
            renderer.GlobalCommandBuffer.DrawMesh(mesh, world, _material, 0, pass);
           
            if (CustomRenderEvent != null)
                CustomRenderEvent(renderer, this, renderer.GlobalCommandBuffer, viewProj);
        }
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="renderer"></param>
    /// <param name="viewProj"></param>
    private void SetupSpotLight(VolumetricLightRenderer renderer, Matrix4x4 viewProj)
    {       
        int pass = 1;
        if (!IsCameraInSpotLightBounds())
        {
            pass = 3;   
        }

        Mesh mesh = VolumetricLightRenderer.GetSpotLightMesh();
               
        float scale = _light.range;
        float angleScale = Mathf.Tan((_light.spotAngle + 1) * 0.5f * Mathf.Deg2Rad) * _light.range;

        Matrix4x4 world = Matrix4x4.TRS(transform.position, transform.rotation, new Vector3(angleScale, angleScale, scale));

        Matrix4x4 view = Matrix4x4.TRS(_light.transform.position, _light.transform.rotation, Vector3.one).inverse;

        Matrix4x4 clip = Matrix4x4.TRS(new Vector3(0.5f, 0.5f, 0.0f), Quaternion.identity, new Vector3(-0.5f, -0.5f, 1.0f));
        Matrix4x4 proj = Matrix4x4.Perspective(_light.spotAngle, 1, 0, 1);

        _material.SetMatrix("_MyLightMatrix0", clip * proj * view);

        _material.SetMatrix("_WorldViewProj", viewProj * world);

        _material.SetVector("_LightPos", new Vector4(_light.transform.position.x, _light.transform.position.y, _light.transform.position.z, 1.0f / (_light.range * _light.range)));
        _material.SetVector("_LightColor", _light.color * _light.intensity);


        Vector3 apex = transform.position;
        Vector3 axis = transform.forward;
        // plane equation ax + by + cz + d = 0; precompute d here to lighten the shader
        Vector3 center = apex + axis * _light.range;
        float d = -Vector3.Dot(center, axis);

        // update material
        _material.SetFloat("_PlaneD", d);       
        _material.SetFloat("_CosAngle", Mathf.Cos((_light.spotAngle + 1) * 0.5f * Mathf.Deg2Rad));

        _material.SetVector("_ConeApex", new Vector4(apex.x, apex.y, apex.z));
        _material.SetVector("_ConeAxis", new Vector4(axis.x, axis.y, axis.z));

        _material.EnableKeyword("SPOT");

        if (Noise)
            _material.EnableKeyword("NOISE");
        else
            _material.DisableKeyword("NOISE");

        if (_light.cookie == null)
        {
            _material.SetTexture("_LightTexture0", VolumetricLightRenderer.GetDefaultSpotCookie());
        }
        else
        {
            _material.SetTexture("_LightTexture0", _light.cookie);
        }

        bool forceShadowsOff = false;
        if ((_light.transform.position - Camera.current.transform.position).magnitude >= QualitySettings.shadowDistance)
            forceShadowsOff = true;

        if (_light.shadows != LightShadows.None && forceShadowsOff == false)
        {
            clip = Matrix4x4.TRS(new Vector3(0.5f, 0.5f, 0.5f), Quaternion.identity, new Vector3(0.5f, 0.5f, 0.5f));

            if(_reversedZ)
                proj = Matrix4x4.Perspective(_light.spotAngle, 1, _light.range, _light.shadowNearPlane);
            else
                proj = Matrix4x4.Perspective(_light.spotAngle, 1, _light.shadowNearPlane, _light.range);

            Matrix4x4 m = clip * proj;
            m[0, 2] *= -1;
            m[1, 2] *= -1;
            m[2, 2] *= -1;
            m[3, 2] *= -1;

            //view = _light.transform.worldToLocalMatrix;
            _material.SetMatrix("_MyWorld2Shadow", m * view);
            _material.SetMatrix("_WorldView", m * view);

            _material.EnableKeyword("SHADOWS_DEPTH");
            _commandBuffer.SetGlobalTexture("_ShadowMapTexture", BuiltinRenderTextureType.CurrentActive);
            _commandBuffer.SetRenderTarget(renderer.GetVolumeLightBuffer());

            _commandBuffer.DrawMesh(mesh, world, _material, 0, pass);

            if (CustomRenderEvent != null)
                CustomRenderEvent(renderer, this, _commandBuffer, viewProj);     
        }
        else
        {
            _material.DisableKeyword("SHADOWS_DEPTH");
            renderer.GlobalCommandBuffer.DrawMesh(mesh, world, _material, 0, pass);

            if (CustomRenderEvent != null)
                CustomRenderEvent(renderer, this, renderer.GlobalCommandBuffer, viewProj);
        }
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="renderer"></param>
    /// <param name="viewProj"></param>
    private void SetupDirectionalLight(VolumetricLightRenderer renderer, Matrix4x4 viewProj)
    {
        int pass = 4;

        _material.SetPass(pass);
       
        if (Noise)
            _material.EnableKeyword("NOISE");
        else
            _material.DisableKeyword("NOISE");

        _material.SetVector("_LightDir", new Vector4(_light.transform.forward.x, _light.transform.forward.y, _light.transform.forward.z, 1.0f / (_light.range * _light.range)));
        _material.SetVector("_LightColor", _light.color * _light.intensity);
        _material.SetFloat("_MaxRayLength", MaxRayLength);

        if (_light.cookie == null)
        {
            _material.EnableKeyword("DIRECTIONAL");
            _material.DisableKeyword("DIRECTIONAL_COOKIE");
        }
        else
        {
            _material.EnableKeyword("DIRECTIONAL_COOKIE");
            _material.DisableKeyword("DIRECTIONAL");

            _material.SetTexture("_LightTexture0", _light.cookie);
        }

        // setup frustum corners for world position reconstruction
        // bottom left
        _frustumCorners[0] = Camera.current.ViewportToWorldPoint(new Vector3(0, 0, Camera.current.farClipPlane));
        // top left
        _frustumCorners[2] = Camera.current.ViewportToWorldPoint(new Vector3(0, 1, Camera.current.farClipPlane));
        // top right
        _frustumCorners[3] = Camera.current.ViewportToWorldPoint(new Vector3(1, 1, Camera.current.farClipPlane));
        // bottom right
        _frustumCorners[1] = Camera.current.ViewportToWorldPoint(new Vector3(1, 0, Camera.current.farClipPlane));

#if UNITY_5_4_OR_NEWER
        _material.SetVectorArray("_FrustumCorners", _frustumCorners);
#else
        _material.SetVector("_FrustumCorners0", _frustumCorners[0]);
        _material.SetVector("_FrustumCorners1", _frustumCorners[1]);
        _material.SetVector("_FrustumCorners2", _frustumCorners[2]);
        _material.SetVector("_FrustumCorners3", _frustumCorners[3]);
#endif

        Texture nullTexture = null;
        if (_light.shadows != LightShadows.None)
        {
            _material.EnableKeyword("SHADOWS_DEPTH");           
            _commandBuffer.Blit(nullTexture, renderer.GetVolumeLightBuffer(), _material, pass);

            if (CustomRenderEvent != null)
                CustomRenderEvent(renderer, this, _commandBuffer, viewProj);
        }
        else
        {
            _material.DisableKeyword("SHADOWS_DEPTH");
            renderer.GlobalCommandBuffer.Blit(nullTexture, renderer.GetVolumeLightBuffer(), _material, pass);

            if (CustomRenderEvent != null)
                CustomRenderEvent(renderer, this, renderer.GlobalCommandBuffer, viewProj);
        }
    }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    private bool IsCameraInPointLightBounds()
    {
        float distanceSqr = (_light.transform.position - Camera.current.transform.position).sqrMagnitude;
        float extendedRange = _light.range + 1;
        if (distanceSqr < (extendedRange * extendedRange))
            return true;
        return false;
    }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    private bool IsCameraInSpotLightBounds()
    {
        // check range
        float distance = Vector3.Dot(_light.transform.forward, (Camera.current.transform.position - _light.transform.position));
        float extendedRange = _light.range + 1;
        if (distance > (extendedRange))
            return false;

        // check angle
        float cosAngle = Vector3.Dot(transform.forward, (Camera.current.transform.position - _light.transform.position).normalized);
        if((Mathf.Acos(cosAngle) * Mathf.Rad2Deg) > (_light.spotAngle + 3) * 0.5f)
            return false;

        return true;
    }
}

Leetz1k
Iniciante
Iniciante

PONTOS : 547
REPUTAÇÃO : 0
Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Leetz1k em Seg Abr 23, 2018 7:05 pm

Código:
using UnityEngine;
using System.Collections;
using UnityEngine.Rendering;
using System;

[RequireComponent(typeof(Camera))]
public class VolumetricLightRenderer : MonoBehaviour
{
    public enum VolumtericResolution
    {
        Full,
        Half,
        Quarter
    };

    public static event Action<VolumetricLightRenderer, Matrix4x4> PreRenderEvent;

    private static Mesh _pointLightMesh;
    private static Mesh _spotLightMesh;
    private static Material _lightMaterial;

    private Camera _camera;
    private CommandBuffer _preLightPass;

    private Matrix4x4 _viewProj;
    private Material _blitAddMaterial;
    private Material _bilateralBlurMaterial;

    private RenderTexture _volumeLightTexture;
    private RenderTexture _halfVolumeLightTexture;
    private RenderTexture _quarterVolumeLightTexture;
    private static Texture _defaultSpotCookie;

    private RenderTexture _halfDepthBuffer;
    private RenderTexture _quarterDepthBuffer;
    private VolumtericResolution _currentResolution = VolumtericResolution.Full;
    private Texture2D _ditheringTexture;
    private Texture3D _noiseTexture;

    public VolumtericResolution Resolution = VolumtericResolution.Full;
    public Texture DefaultSpotCookie;

    public CommandBuffer GlobalCommandBuffer { get { return _preLightPass; } }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    public static Material GetLightMaterial()
    {
        return _lightMaterial;
    }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    public static Mesh GetPointLightMesh()
    {
        return _pointLightMesh;
    }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    public static Mesh GetSpotLightMesh()
    {
        return _spotLightMesh;
    }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    public RenderTexture GetVolumeLightBuffer()
    {
        if (Resolution == VolumtericResolution.Quarter)
            return _quarterVolumeLightTexture;
        else if (Resolution == VolumtericResolution.Half)
            return _halfVolumeLightTexture;
        else
            return _volumeLightTexture;
    }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    public RenderTexture GetVolumeLightDepthBuffer()
    {
        if (Resolution == VolumtericResolution.Quarter)
            return _quarterDepthBuffer;
        else if (Resolution == VolumtericResolution.Half)
            return _halfDepthBuffer;
        else
            return null;
    }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    public static Texture GetDefaultSpotCookie()
    {
        return _defaultSpotCookie;
    }

    /// <summary>
    ///
    /// </summary>
    void Awake()
    {
        _camera = GetComponent<Camera>();
        if (_camera.actualRenderingPath == RenderingPath.Forward)
            _camera.depthTextureMode = DepthTextureMode.Depth;

        _currentResolution = Resolution;

        Shader shader = Shader.Find("Hidden/BlitAdd");
        if (shader == null)
            throw new Exception("Critical Error: \"Hidden/BlitAdd\" shader is missing. Make sure it is included in \"Always Included Shaders\" in ProjectSettings/Graphics.");
        _blitAddMaterial = new Material(shader);

        shader = Shader.Find("Hidden/BilateralBlur");
        if (shader == null)
            throw new Exception("Critical Error: \"Hidden/BilateralBlur\" shader is missing. Make sure it is included in \"Always Included Shaders\" in ProjectSettings/Graphics.");
        _bilateralBlurMaterial = new Material(shader);

        _preLightPass = new CommandBuffer();
        _preLightPass.name = "PreLight";

        ChangeResolution();

        if (_pointLightMesh == null)
        {
            GameObject go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            _pointLightMesh = go.GetComponent<MeshFilter>().sharedMesh;
            Destroy(go);
        }

        if (_spotLightMesh == null)
        {
            _spotLightMesh = CreateSpotLightMesh();
        }

        if (_lightMaterial == null)
        {
            shader = Shader.Find("Sandbox/VolumetricLight");
            if (shader == null)
                throw new Exception("Critical Error: \"Sandbox/VolumetricLight\" shader is missing. Make sure it is included in \"Always Included Shaders\" in ProjectSettings/Graphics.");
            _lightMaterial = new Material(shader);
        }

        if (_defaultSpotCookie == null)
        {
            _defaultSpotCookie = DefaultSpotCookie;
        }

        LoadNoise3dTexture();
        GenerateDitherTexture();
    }

    /// <summary>
    ///
    /// </summary>
    void OnEnable()
    {
        http://_camera.RemoveAllCommandBuffers();
        if(_camera.actualRenderingPath == RenderingPath.Forward)
            _camera.AddCommandBuffer(CameraEvent.AfterDepthTexture, _preLightPass);
        else
            _camera.AddCommandBuffer(CameraEvent.BeforeLighting, _preLightPass);
    }

    /// <summary>
    ///
    /// </summary>
    void OnDisable()
    {
        http://_camera.RemoveAllCommandBuffers();
        if(_camera.actualRenderingPath == RenderingPath.Forward)
            _camera.RemoveCommandBuffer(CameraEvent.AfterDepthTexture, _preLightPass);
        else
            _camera.RemoveCommandBuffer(CameraEvent.BeforeLighting, _preLightPass);
    }

    /// <summary>
    ///
    /// </summary>
    void ChangeResolution()
    {
        int width = _camera.pixelWidth;
        int height = _camera.pixelHeight;

        if (_volumeLightTexture != null)
            Destroy(_volumeLightTexture);

        _volumeLightTexture = new RenderTexture(width, height, 0, RenderTextureFormat.ARGBHalf);
        _volumeLightTexture.name = "VolumeLightBuffer";
        _volumeLightTexture.filterMode = FilterMode.Bilinear;

        if (_halfDepthBuffer != null)
            Destroy(_halfDepthBuffer);
        if (_halfVolumeLightTexture != null)
            Destroy(_halfVolumeLightTexture);

        if (Resolution == VolumtericResolution.Half || Resolution == VolumtericResolution.Quarter)
        {
            _halfVolumeLightTexture = new RenderTexture(width / 2, height / 2, 0, RenderTextureFormat.ARGBHalf);
            _halfVolumeLightTexture.name = "VolumeLightBufferHalf";
            _halfVolumeLightTexture.filterMode = FilterMode.Bilinear;

            _halfDepthBuffer = new RenderTexture(width / 2, height / 2, 0, RenderTextureFormat.RFloat);
            _halfDepthBuffer.name = "VolumeLightHalfDepth";
            _halfDepthBuffer.Create();
            _halfDepthBuffer.filterMode = FilterMode.Point;
        }

        if (_quarterVolumeLightTexture != null)
            Destroy(_quarterVolumeLightTexture);
        if (_quarterDepthBuffer != null)
            Destroy(_quarterDepthBuffer);

        if (Resolution == VolumtericResolution.Quarter)
        {
            _quarterVolumeLightTexture = new RenderTexture(width / 4, height / 4, 0, RenderTextureFormat.ARGBHalf);
            _quarterVolumeLightTexture.name = "VolumeLightBufferQuarter";
            _quarterVolumeLightTexture.filterMode = FilterMode.Bilinear;

            _quarterDepthBuffer = new RenderTexture(width / 4, height / 4, 0, RenderTextureFormat.RFloat);
            _quarterDepthBuffer.name = "VolumeLightQuarterDepth";
            _quarterDepthBuffer.Create();
            _quarterDepthBuffer.filterMode = FilterMode.Point;
        }
    }

    /// <summary>
    ///
    /// </summary>
    public void OnPreRender()
    {
        // use very low value for near clip plane to simplify cone/frustum intersection
        Matrix4x4 proj = Matrix4x4.Perspective(_camera.fieldOfView, _camera.aspect, 0.01f, _camera.farClipPlane);
        proj = GL.GetGPUProjectionMatrix(proj, true);

        _viewProj = proj * _camera.worldToCameraMatrix;

        _preLightPass.Clear();

        bool dx11 = SystemInfo.graphicsShaderLevel > 40;

        if (Resolution == VolumtericResolution.Quarter)
        {
            Texture nullTexture = null;
            // down sample depth to half res
            _preLightPass.Blit(nullTexture, _halfDepthBuffer, _bilateralBlurMaterial, dx11 ? 4 : 10);
            // down sample depth to quarter res
            _preLightPass.Blit(nullTexture, _quarterDepthBuffer, _bilateralBlurMaterial, dx11 ? 6 : 11);

            _preLightPass.SetRenderTarget(_quarterVolumeLightTexture);
        }
        else if (Resolution == VolumtericResolution.Half)
        {
            Texture nullTexture = null;
            // down sample depth to half res
            _preLightPass.Blit(nullTexture, _halfDepthBuffer, _bilateralBlurMaterial, dx11 ? 4 : 10);

            _preLightPass.SetRenderTarget(_halfVolumeLightTexture);
        }
        else
        {
            _preLightPass.SetRenderTarget(_volumeLightTexture);
        }

        _preLightPass.ClearRenderTarget(false, true, new Color(0, 0, 0, 1));

        UpdateMaterialParameters();

        if (PreRenderEvent != null)
            PreRenderEvent(this, _viewProj);
    }

    [ImageEffectOpaque]
    public void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        if (Resolution == VolumtericResolution.Quarter)
        {
            RenderTexture temp = RenderTexture.GetTemporary(_quarterDepthBuffer.width, _quarterDepthBuffer.height, 0, RenderTextureFormat.ARGBHalf);
            temp.filterMode = FilterMode.Bilinear;

            // horizontal bilateral blur at quarter res
            Graphics.Blit(_quarterVolumeLightTexture, temp, _bilateralBlurMaterial, 8);
            // vertical bilateral blur at quarter res
            Graphics.Blit(temp, _quarterVolumeLightTexture, _bilateralBlurMaterial, 9);

            // upscale to full res
            Graphics.Blit(_quarterVolumeLightTexture, _volumeLightTexture, _bilateralBlurMaterial, 7);

            RenderTexture.ReleaseTemporary(temp);
        }
        else if (Resolution == VolumtericResolution.Half)
        {
            RenderTexture temp = RenderTexture.GetTemporary(_halfVolumeLightTexture.width, _halfVolumeLightTexture.height, 0, RenderTextureFormat.ARGBHalf);
            temp.filterMode = FilterMode.Bilinear;

            // horizontal bilateral blur at half res
            Graphics.Blit(_halfVolumeLightTexture, temp, _bilateralBlurMaterial, 2);
           
            // vertical bilateral blur at half res
            Graphics.Blit(temp, _halfVolumeLightTexture, _bilateralBlurMaterial, 3);
           
            // upscale to full res
            Graphics.Blit(_halfVolumeLightTexture, _volumeLightTexture, _bilateralBlurMaterial, 5);
            RenderTexture.ReleaseTemporary(temp);
        }
        else
        {
            RenderTexture temp = RenderTexture.GetTemporary(_volumeLightTexture.width, _volumeLightTexture.height, 0, RenderTextureFormat.ARGBHalf);
            temp.filterMode = FilterMode.Bilinear;

            // horizontal bilateral blur at full res
            Graphics.Blit(_volumeLightTexture, temp, _bilateralBlurMaterial, 0);
            // vertical bilateral blur at full res
            Graphics.Blit(temp, _volumeLightTexture, _bilateralBlurMaterial, 1);
            RenderTexture.ReleaseTemporary(temp);
        }
       
        // add volume light buffer to rendered scene
        _blitAddMaterial.SetTexture("_Source", source);
        Graphics.Blit(_volumeLightTexture, destination, _blitAddMaterial, 0);
    }

    private void UpdateMaterialParameters()
    {
        _bilateralBlurMaterial.SetTexture("_HalfResDepthBuffer", _halfDepthBuffer);
        _bilateralBlurMaterial.SetTexture("_HalfResColor", _halfVolumeLightTexture);
        _bilateralBlurMaterial.SetTexture("_QuarterResDepthBuffer", _quarterDepthBuffer);
        _bilateralBlurMaterial.SetTexture("_QuarterResColor", _quarterVolumeLightTexture);

        Shader.SetGlobalTexture("_DitherTexture", _ditheringTexture);
        Shader.SetGlobalTexture("_NoiseTexture", _noiseTexture);
    }

    /// <summary>
    ///
    /// </summary>
    void Update()
    {
        //#if UNITY_EDITOR
        if (_currentResolution != Resolution)
        {
            _currentResolution = Resolution;
            ChangeResolution();
        }

        if ((_volumeLightTexture.width != _camera.pixelWidth || _volumeLightTexture.height != _camera.pixelHeight))
            ChangeResolution();
        //#endif
    }

    /// <summary>
    ///
    /// </summary>
    void LoadNoise3dTexture()
    {
        // basic dds loader for 3d texture - !not very robust!

        TextAsset data = Resources.Load("NoiseVolume") as TextAsset;

        byte[] bytes = data.bytes;

        uint height = BitConverter.ToUInt32(data.bytes, 12);
        uint width = BitConverter.ToUInt32(data.bytes, 16);
        uint pitch = BitConverter.ToUInt32(data.bytes, 20);
        uint depth = BitConverter.ToUInt32(data.bytes, 24);
        uint formatFlags = BitConverter.ToUInt32(data.bytes, 20 * 4);
        uint bitdepth = BitConverter.ToUInt32(data.bytes, 22 * 4);
        if (bitdepth == 0)
            bitdepth = pitch / width * 8;


        // doesn't work with TextureFormat.Alpha8 for some reason
        _noiseTexture = new Texture3D((int)width, (int)height, (int)depth, TextureFormat.RGBA32, false);
        _noiseTexture.name = "3D Noise";

        Color[] c = new Color[width * height * depth];

        uint index = 128;
        if (data.bytes[21 * 4] == 'D' && data.bytes[21 * 4 + 1] == 'X' && data.bytes[21 * 4 + 2] == '1' && data.bytes[21 * 4 + 3] == '0' &&
            (formatFlags & 0x4) != 0)
        {
            uint format = BitConverter.ToUInt32(data.bytes, (int)index);
            if (format >= 60 && format <= 65)
                bitdepth = 8;
            else if (format >= 48 && format <= 52)
                bitdepth = 16;
            else if (format >= 27 && format <= 32)
                bitdepth = 32;

            http://Debug.Log("DXGI format: " + format);
            // dx10 format, skip dx10 header
            http://Debug.Log("DX10 format");
            index += 20;
        }

        uint byteDepth = bitdepth / 8;
        pitch = (width * bitdepth + 7) / 8;

        for (int d = 0; d < depth; ++d)
        {
            //index = 128;
            for (int h = 0; h < height; ++h)
            {
                for (int w = 0; w < width; ++w)
                {
                    float v = (bytes[index + w * byteDepth] / 255.0f);
                    c[w + h * width + d * width * height] = new Color(v, v, v, v);
                }

                index += pitch;
            }
        }

        _noiseTexture.SetPixels(c);
        _noiseTexture.Apply();
    }

    /// <summary>
    ///
    /// </summary>
    private void GenerateDitherTexture()
    {
        if (_ditheringTexture != null)
        {
            return;
        }

        int size = 8;
#if DITHER_4_4
        size = 4;
#endif
        // again, I couldn't make it work with Alpha8
        _ditheringTexture = new Texture2D(size, size, TextureFormat.Alpha8, false, true);
        _ditheringTexture.filterMode = FilterMode.Point;
        Color32[] c = new Color32[size * size];

        byte b;
#if DITHER_4_4
        b = (byte)(0.0f / 16.0f * 255); c[0] = new Color32(b, b, b, b);
        b = (byte)(8.0f / 16.0f * 255); c[1] = new Color32(b, b, b, b);
        b = (byte)(2.0f / 16.0f * 255); c[2] = new Color32(b, b, b, b);
        b = (byte)(10.0f / 16.0f * 255); c[3] = new Color32(b, b, b, b);

        b = (byte)(12.0f / 16.0f * 255); c[4] = new Color32(b, b, b, b);
        b = (byte)(4.0f / 16.0f * 255); c[5] = new Color32(b, b, b, b);
        b = (byte)(14.0f / 16.0f * 255); c[6] = new Color32(b, b, b, b);
        b = (byte)(6.0f / 16.0f * 255); c[7] = new Color32(b, b, b, b);

        b = (byte)(3.0f / 16.0f * 255); c[8] = new Color32(b, b, b, b);
        b = (byte)(11.0f / 16.0f * 255); c[9] = new Color32(b, b, b, b);
        b = (byte)(1.0f / 16.0f * 255); c[10] = new Color32(b, b, b, b);
        b = (byte)(9.0f / 16.0f * 255); c[11] = new Color32(b, b, b, b);

        b = (byte)(15.0f / 16.0f * 255); c[12] = new Color32(b, b, b, b);
        b = (byte)(7.0f / 16.0f * 255); c[13] = new Color32(b, b, b, b);
        b = (byte)(13.0f / 16.0f * 255); c[14] = new Color32(b, b, b, b);
        b = (byte)(5.0f / 16.0f * 255); c[15] = new Color32(b, b, b, b);
#else
        int i = 0;
        b = (byte)(1.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(49.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(13.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(61.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(4.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(52.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(16.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(64.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);

        b = (byte)(33.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(17.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(45.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(29.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(36.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(20.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(48.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(32.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);

        b = (byte)(9.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(57.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(5.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(53.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(12.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(60.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(8.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(56.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);

        b = (byte)(41.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(25.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(37.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(21.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(44.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(28.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(40.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(24.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);

        b = (byte)(3.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(51.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(15.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(63.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(2.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(50.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(14.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(62.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);

        b = (byte)(35.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(19.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(47.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(31.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(34.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(18.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(46.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(30.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);

        b = (byte)(11.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(59.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(7.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(55.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(10.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(58.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(6.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(54.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);

        b = (byte)(43.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(27.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(39.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(23.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(42.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(26.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(38.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
        b = (byte)(22.0f / 65.0f * 255); c[i++] = new Color32(b, b, b, b);
#endif

        _ditheringTexture.SetPixels32(c);
        _ditheringTexture.Apply();
    }

    /// <summary>
    ///
    /// </summary>
    /// <returns></returns>
    private Mesh CreateSpotLightMesh()
    {
        // copy & pasted from other project, the geometry is too complex, should be simplified
        Mesh mesh = new Mesh();

        const int segmentCount = 16;
        Vector3[] vertices = new Vector3[2 + segmentCount * 3];
        Color32[] colors = new Color32[2 + segmentCount * 3];

        vertices[0] = new Vector3(0, 0, 0);
        vertices[1] = new Vector3(0, 0, 1);

        float angle = 0;
        float step = Mathf.PI * 2.0f / segmentCount;
        float ratio = 0.9f;

        for (int i = 0; i < segmentCount; ++i)
        {
            vertices[i + 2] = new Vector3(-Mathf.Cos(angle) * ratio, Mathf.Sin(angle) * ratio, ratio);
            colors[i + 2] = new Color32(255, 255, 255, 255);
            vertices[i + 2 + segmentCount] = new Vector3(-Mathf.Cos(angle), Mathf.Sin(angle), 1);
            colors[i + 2 + segmentCount] = new Color32(255, 255, 255, 0);
            vertices[i + 2 + segmentCount * 2] = new Vector3(-Mathf.Cos(angle) * ratio, Mathf.Sin(angle) * ratio, 1);
            colors[i + 2 + segmentCount * 2] = new Color32(255, 255, 255, 255);
            angle += step;
        }

        mesh.vertices = vertices;
        mesh.colors32 = colors;

        int[] indices = new int[segmentCount * 3 * 2 + segmentCount * 6 * 2];
        int index = 0;

        for (int i = 2; i < segmentCount + 1; ++i)
        {
            indices[index++] = 0;
            indices[index++] = i;
            indices[index++] = i + 1;
        }

        indices[index++] = 0;
        indices[index++] = segmentCount + 1;
        indices[index++] = 2;

        for (int i = 2; i < segmentCount + 1; ++i)
        {
            indices[index++] = i;
            indices[index++] = i + segmentCount;
            indices[index++] = i + 1;

            indices[index++] = i + 1;
            indices[index++] = i + segmentCount;
            indices[index++] = i + segmentCount + 1;
        }

        indices[index++] = 2;
        indices[index++] = 1 + segmentCount;
        indices[index++] = 2 + segmentCount;

        indices[index++] = 2 + segmentCount;
        indices[index++] = 1 + segmentCount;
        indices[index++] = 1 + segmentCount + segmentCount;

        //------------
        for (int i = 2 + segmentCount; i < segmentCount + 1 + segmentCount; ++i)
        {
            indices[index++] = i;
            indices[index++] = i + segmentCount;
            indices[index++] = i + 1;

            indices[index++] = i + 1;
            indices[index++] = i + segmentCount;
            indices[index++] = i + segmentCount + 1;
        }

        indices[index++] = 2 + segmentCount;
        indices[index++] = 1 + segmentCount * 2;
        indices[index++] = 2 + segmentCount * 2;

        indices[index++] = 2 + segmentCount * 2;
        indices[index++] = 1 + segmentCount * 2;
        indices[index++] = 1 + segmentCount * 3;

        ////-------------------------------------
        for (int i = 2 + segmentCount * 2; i < segmentCount * 3 + 1; ++i)
        {
            indices[index++] = 1;
            indices[index++] = i + 1;
            indices[index++] = i;
        }

        indices[index++] = 1;
        indices[index++] = 2 + segmentCount * 2;
        indices[index++] = segmentCount * 3 + 1;

        mesh.triangles = indices;
        mesh.RecalculateBounds();

        return mesh;
    }
}

Leetz1k
Iniciante
Iniciante

PONTOS : 547
REPUTAÇÃO : 0
Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Leetz1k em Seg Abr 23, 2018 7:06 pm

Só não sei como insiro um video ou imagem

Leetz1k
Iniciante
Iniciante

PONTOS : 547
REPUTAÇÃO : 0
Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Leetz1k em Seg Abr 23, 2018 7:08 pm



Leetz1k
Iniciante
Iniciante

PONTOS : 547
REPUTAÇÃO : 0
Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por NKKF em Seg Abr 23, 2018 8:07 pm

Mande em um link. Upe em algum lugar.
avatar
NKKF
ProgramadorMaster

Masculino PONTOS : 1852
REPUTAÇÃO : 385
Idade : 13
Áreas de atuação : Error 404 Not Found.
Respeito as regras :

Ver perfil do usuário http://www.projetounity.esy.es

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Leetz1k em Seg Abr 23, 2018 8:10 pm


Leetz1k
Iniciante
Iniciante

PONTOS : 547
REPUTAÇÃO : 0
Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

DÚVIDA Re: Estou com problemas na iluminação da minha Lanterna (jogo de terror)

Mensagem por Leetz1k em Seg Abr 23, 2018 8:11 pm


Leetz1k
Iniciante
Iniciante

PONTOS : 547
REPUTAÇÃO : 0
Respeito as regras :

Ver perfil do usuário

Voltar ao Topo Ir em baixo

Voltar ao Topo

- Tópicos similares

 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum