RenderData.cs

using System;
using UnityEngine;
 
// Token: 0x02000196 RID: 406
public class RenderData : EScriptable, IRenderer
{
    // Token: 0x170002E5 RID: 741
    // (get) Token: 0x06000BC2 RID: 3010 RVA: 0x00048949 File Offset: 0x00046B49
    public static Quaternion shadowRotation
    {
        get
        {
            return Quaternion.Euler(0f, 0f, RenderData.renderSetting.shadowAngle);
        }
    }
 
    // Token: 0x170002E6 RID: 742
    // (get) Token: 0x06000BC3 RID: 3011 RVA: 0x00048964 File Offset: 0x00046B64
    public static Vector3 shadowScale
    {
        get
        {
            return RenderData.renderSetting.shadowScale;
        }
    }
 
    // Token: 0x170002E7 RID: 743
    // (get) Token: 0x06000BC4 RID: 3012 RVA: 0x00048970 File Offset: 0x00046B70
    public static Vector3 shadowOffset
    {
        get
        {
            return RenderData.renderSetting.shadowOffset;
        }
    }
 
    // Token: 0x170002E8 RID: 744
    // (get) Token: 0x06000BC5 RID: 3013 RVA: 0x0004897C File Offset: 0x00046B7C
    public virtual bool SkipOnMap
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x170002E9 RID: 745
    // (get) Token: 0x06000BC6 RID: 3014 RVA: 0x0004897F File Offset: 0x00046B7F
    public virtual string pathSprite
    {
        get
        {
            return "Scene/Render/Data/";
        }
    }
 
    // Token: 0x170002EA RID: 746
    // (get) Token: 0x06000BC7 RID: 3015 RVA: 0x00048986 File Offset: 0x00046B86
    public virtual string prefabName
    {
        get
        {
            return "ThingActor";
        }
    }
 
    // Token: 0x06000BC8 RID: 3016 RVA: 0x0004898D File Offset: 0x00046B8D
    public virtual CardActor CreateActor()
    {
        return null;
    }
 
    // Token: 0x170002EB RID: 747
    // (get) Token: 0x06000BC9 RID: 3017 RVA: 0x00048990 File Offset: 0x00046B90
    public virtual bool ForceAltHeldPosition
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x06000BCA RID: 3018 RVA: 0x00048993 File Offset: 0x00046B93
    private void Awake()
    {
        this.Init();
    }
 
    // Token: 0x06000BCB RID: 3019 RVA: 0x0004899C File Offset: 0x00046B9C
    public void Init()
    {
        if (this.initialized)
        {
            return;
        }
        this.initialized = true;
        this._offset = this.offset;
        MeshPass meshPass = this.pass;
        this.hasSubPass = ((meshPass != null) ? meshPass.subPass : null);
        MeshPass meshPass2 = this.pass;
        this.hasSnowPass = ((meshPass2 != null) ? meshPass2.snowPass : null);
        this.OnInit();
    }
 
    // Token: 0x06000BCC RID: 3020 RVA: 0x00048A05 File Offset: 0x00046C05
    public virtual void OnInit()
    {
    }
 
    // Token: 0x06000BCD RID: 3021 RVA: 0x00048A07 File Offset: 0x00046C07
    public int ConvertTile(int tile)
    {
        return tile / 100 * (int)this.pass.pmesh.tiling.x + tile % 100;
    }
 
    // Token: 0x06000BCE RID: 3022 RVA: 0x00048A2C File Offset: 0x00046C2C
    public void RenderToRenderCam(RenderParam p)
    {
        Vector3 renderPos = EClass.scene.camSupport.renderPos;
        if (this.multiSize)
        {
            renderPos.y -= 0.8f;
        }
        p.x = renderPos.x;
        p.y = renderPos.y;
        p.z = renderPos.z;
        this.Draw(p);
    }
 
    // Token: 0x06000BCF RID: 3023 RVA: 0x00048A8C File Offset: 0x00046C8C
    public void Draw(RenderParam p, int tile)
    {
        p.tile = (float)tile;
        this.Draw(p);
    }
 
    // Token: 0x06000BD0 RID: 3024 RVA: 0x00048AA0 File Offset: 0x00046CA0
    public virtual void Draw(RenderParam p)
    {
        MeshPass meshPass = (this.hasSubPass && SubPassData.Current.enable) ? this.pass.subPass : this.pass;
        MeshBatch meshBatch = meshPass.batches[meshPass.batchIdx];
        int num = (p.tile > 0f) ? 1 : -1;
        if (this.useOffsetBack)
        {
            this._offset = ((p.dir == 2 || p.dir == 3) ? this.offsetBack : this.offset);
        }
        if (meshPass == this.pass.subPass)
        {
            meshBatch.colors[meshPass.idx] = p.color - 1572864f;
            meshBatch.matrices[meshPass.idx].SetTRS(p.NewVector3 + this._offset + SubPassData.Current.offset, SubPassData.Current.rotation, SubPassData.Current.scale);
        }
        else
        {
            meshBatch.colors[meshPass.idx] = p.color;
            meshBatch.matrices[meshPass.idx].m03 = p.x + this._offset.x * (float)num;
            meshBatch.matrices[meshPass.idx].m13 = p.y + this._offset.y;
            meshBatch.matrices[meshPass.idx].m23 = p.z + this._offset.z;
        }
        meshBatch.tiles[meshPass.idx] = p.tile + (float)(p.liquidLv * 10000 * num);
        meshPass.idx++;
        if (meshPass.idx == meshPass.batchSize)
        {
            meshPass.NextBatch();
        }
    }
 
    // Token: 0x06000BD1 RID: 3025 RVA: 0x00048C75 File Offset: 0x00046E75
    private void OnValidate()
    {
        this._offset = this.offset;
    }
 
    // Token: 0x06000BD2 RID: 3026 RVA: 0x00048C84 File Offset: 0x00046E84
    public void DrawRepeatTo(RenderParam p, float maxY, float height, ref Vector3 peakFix, bool skipFirst = false, int fire = 0, bool isBlock = false)
    {
        int num = (int)((maxY + height + peakFix.x - p.y) / peakFix.y);
        bool snow = p.snow;
        if (num == 0)
        {
            if (!skipFirst)
            {
                this.Draw(p);
            }
            return;
        }
        this.orgY = p.y;
        this.orgZ = p.z;
        p.snow = (!isBlock && snow);
        for (int i = 0; i < num + 1; i++)
        {
            if (i == num)
            {
                p.y = maxY + height - peakFix.y;
                p.z -= peakFix.z + peakFix.x;
                p.snow = snow;
            }
            if (skipFirst)
            {
                if (i != 0 && num > 1)
                {
                    this.Draw(p);
                }
            }
            else
            {
                this.Draw(p);
            }
            if (fire > 0 && i != num)
            {
                EClass.screen.tileMap.rendererEffect.Draw(p, fire);
                fire--;
            }
            p.y += peakFix.y;
            p.z += peakFix.z;
        }
        p.y = this.orgY;
        p.z = this.orgZ;
    }
 
    // Token: 0x06000BD3 RID: 3027 RVA: 0x00048DB8 File Offset: 0x00046FB8
    public void DrawRepeat(RenderParam p, int count, float size, bool skipFirst = false)
    {
        if (count == 1)
        {
            if (!skipFirst)
            {
                this.Draw(p);
            }
            return;
        }
        bool snow = p.snow;
        this.orgY = p.y;
        this.orgZ = p.z;
        p.snow = false;
        for (int i = 0; i < count; i++)
        {
            if (i == count - 1)
            {
                p.snow = snow;
            }
            if (i != 0 || !skipFirst)
            {
                this.Draw(p);
            }
            p.y += RenderData.renderSetting.peakFix.y * size;
            p.z += RenderData.renderSetting.peakFix.z * size;
        }
        p.y = this.orgY;
        p.z = this.orgZ;
    }
 
    // Token: 0x06000BD4 RID: 3028 RVA: 0x00048E76 File Offset: 0x00047076
    public virtual void DrawWithRotation(RenderParam p, float angle)
    {
    }
 
    // Token: 0x06000BD5 RID: 3029 RVA: 0x00048E78 File Offset: 0x00047078
    public virtual void DrawShadow(RenderParam p)
    {
        int num = (p.tile > 0f) ? 1 : -1;
        MeshPass shadowPass = this.pass.shadowPass;
        MeshBatch meshBatch = shadowPass.batches[shadowPass.batchIdx];
        meshBatch.matrices[shadowPass.idx].SetTRS(p.NewVector3 + this.offset + RenderData.shadowOffset, RenderData.shadowRotation, RenderData.shadowScale);
        meshBatch.tiles[shadowPass.idx] = p.tile;
        shadowPass.idx++;
        if (shadowPass.idx == shadowPass.batchSize)
        {
            shadowPass.NextBatch();
        }
        if (this.multiSize)
        {
            shadowPass = this.pass.shadowPass;
            MeshBatch meshBatch2 = shadowPass.batches[shadowPass.batchIdx];
            meshBatch2.matrices[shadowPass.idx].SetTRS(p.v + this.offsetShadow, RenderData.shadowRotation, RenderData.shadowScale);
            meshBatch2.tiles[shadowPass.idx] = p.tile - this.pass.pmesh.tiling.x * (float)num;
            shadowPass.idx++;
            if (shadowPass.idx == shadowPass.batchSize)
            {
                shadowPass.NextBatch();
            }
        }
    }
 
    // Token: 0x04000ABB RID: 2747
    public const int HeldLightMod = 1572864;
 
    // Token: 0x04000ABC RID: 2748
    public static Quaternion deadRotation = Quaternion.Euler(0f, 0f, 90f);
 
    // Token: 0x04000ABD RID: 2749
    protected Vector3 _offset;
 
    // Token: 0x04000ABE RID: 2750
    public static GameSetting.RenderSetting renderSetting;
 
    // Token: 0x04000ABF RID: 2751
    public int idShadow;
 
    // Token: 0x04000AC0 RID: 2752
    public MeshPass pass;
 
    // Token: 0x04000AC1 RID: 2753
    public Vector3 offset;
 
    // Token: 0x04000AC2 RID: 2754
    public Vector3 offsetBack;
 
    // Token: 0x04000AC3 RID: 2755
    public Vector3 offsetShadow;
 
    // Token: 0x04000AC4 RID: 2756
    public Vector3 heldPos;
 
    // Token: 0x04000AC5 RID: 2757
    public Vector2 imagePivot = new Vector2(0.5f, 0.25f);
 
    // Token: 0x04000AC6 RID: 2758
    public Vector2 imageScale = new Vector2(1f, 1f);
 
    // Token: 0x04000AC7 RID: 2759
    public Vector2 size;
 
    // Token: 0x04000AC8 RID: 2760
    public bool multiSize;
 
    // Token: 0x04000AC9 RID: 2761
    public bool animate;
 
    // Token: 0x04000ACA RID: 2762
    public bool useOffsetBack;
 
    // Token: 0x04000ACB RID: 2763
    public bool persistActor;
 
    // Token: 0x04000ACC RID: 2764
    public bool symmetry = true;
 
    // Token: 0x04000ACD RID: 2765
    public float hangedFixZ;
 
    // Token: 0x04000ACE RID: 2766
    public float stackZ;
 
    // Token: 0x04000ACF RID: 2767
    public SubPassData subCrate;
 
    // Token: 0x04000AD0 RID: 2768
    public SourcePref shadowPref;
 
    // Token: 0x04000AD1 RID: 2769
    public RenderData subData;
 
    // Token: 0x04000AD2 RID: 2770
    [NonSerialized]
    public bool initialized;
 
    // Token: 0x04000AD3 RID: 2771
    [NonSerialized]
    private Sprite _sprite;
 
    // Token: 0x04000AD4 RID: 2772
    [NonSerialized]
    public bool hasSubPass;
 
    // Token: 0x04000AD5 RID: 2773
    [NonSerialized]
    public bool hasSnowPass;
 
    // Token: 0x04000AD6 RID: 2774
    private float orgX;
 
    // Token: 0x04000AD7 RID: 2775
    private float orgY;
 
    // Token: 0x04000AD8 RID: 2776
    private float orgZ;
}