CampaignEngineGlowIndividualEngine.java

Go to the documentation of this file.

package com.fs.starfarer.api.util;
 
import java.awt.Color;
 
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector2f;
 
import com.fs.starfarer.api.Global;
import com.fs.starfarer.api.graphics.SpriteAPI;
 
public class CampaignEngineGlowIndividualEngine {
 
    protected float angle;
    protected float length;
    protected float glowSize;
    protected float width;
    protected float flameTexSpanMult = 1f;
    protected Vector2f offset;
    
    protected Color fringe;
    protected Color core;
    protected Color flameColor;
    protected FaderUtil fader = new FaderUtil(0f, 1f, 1f);
    
    protected FlickerUtilV2 flicker = new FlickerUtilV2();
    protected float texOffset;
    
    
    protected CampaignEngineGlowUtil main;
    
    transient protected SpriteAPI glow;
    transient protected SpriteAPI flame;
    
    public CampaignEngineGlowIndividualEngine(float angle, float length, float width, float glowSize, 
                                        Vector2f offset,
                                        CampaignEngineGlowUtil main) {
        this.angle = angle;
        this.length = length;
        this.glowSize = glowSize;
        this.width = width;
        this.offset = offset;
        this.main = main;
        
        fader.fadeIn();
        
        readResolve();
    }
 
    protected Object readResolve() {
        glow = Global.getSettings().getSprite("campaignEntities", "campaign_engine_glow");
        flame = Global.getSettings().getSprite("campaignEntities", "campaign_engine_flame");
//      flame = Global.getSettings().getSprite("graphics/fx/beam_chunky_fringe.png");
//      flame = Global.getSettings().getSprite("graphics/fx/beamfringe.png");
//      flame = Global.getSettings().getSprite("graphics/fx/beamfringec.png");
//      flame = Global.getSettings().getSprite("graphics/fx/engineglow32.png");
        return this;
    }
    
    public void advance(float amount) {
        fader.advance(amount);
        flicker.advance(amount * main.getFlickerRateMult().getCurr());
        
        texOffset -= amount * main.getTextureScrollMult().getCurr();
        while (texOffset < 0) texOffset += 1f;
    }
    
 
    public void render(Vector2f center, float facing, float alphaMult) {
        alphaMult *= fader.getBrightness();
        
        float f = main.getFlickerMult().getCurr();
        if (f > 0) {
            alphaMult *= (1f - flicker.getBrightness() * f);
            //alphaMult *= flicker.getBrightness() * f;
        }
        
        if (alphaMult <= 0) return;
        
        GL11.glPushMatrix();
        GL11.glTranslatef(center.x, center.y, 0f);
        GL11.glRotatef(facing, 0, 0, 1);
        GL11.glTranslatef(offset.x, offset.y, 0f);
        
        
        renderFlame(alphaMult);
        renderGlow(alphaMult);
        
        
        GL11.glPopMatrix();
    }
    
    protected void renderFlame(float alphaMult) {
        float lengthMult = main.getLengthMult().getCurr();
        float widthMult = main.getWidthMult().getCurr();
        
        if (lengthMult <= 0f || widthMult <= 0f || width <= 0f || length <= 0f) return;
        
        flame.bindTexture();
        
        Color base = main.getFlameColor().getCurr();
        if (flameColor != null) base = flameColor;
        Color dim = Misc.setAlpha(base, 0);
        
        //System.out.println("FC red: " + base.getRed());
        
        float w = width * widthMult;
        float len = length * lengthMult; 
        
//      len *= 2f;
//      w *= 1.5f;
        
        float bit = 0.01f;
        float fadeInPortion = Math.min(w/2f, len/4f);
        float fadeInTex = fadeInPortion / len;
        float flameTexSpan = 1f;
        //flameTexSpan = len / flame.getWidth();
        
        flameTexSpan = len / w * 0.25f;
        //System.out.println("FTX: " + flameTexSpan);
        flameTexSpan *= flameTexSpanMult;
        //flameTexSpan *= 0.5f;
        //flameTexSpan *= 2f;
        
        
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        
        float num = 11f;
        //num = 6f;
        for (float f = 1f; f <= num; f++) {
            float b = alphaMult * f / num; 
            float wMult = 1f - ((f - 1f) / (num - 1f));
            float lMult = f / num;
            lMult = 0.5f + 0.5f * lMult;
            //lMult = (float) Math.sqrt(lMult);
            
            float texPlus = (f - 1f) * 1.0f / num;
            
            GL11.glBegin(GL11.GL_QUAD_STRIP);
            Misc.setColor(dim, alphaMult * b);
            GL11.glTexCoord2f(texOffset + texPlus, 0 + bit);
            GL11.glVertex2f(0f, -w/2f * wMult);
            GL11.glTexCoord2f(texOffset + texPlus, 1 - bit);
            GL11.glVertex2f(0f, w/2f * wMult);
            
            Misc.setColor(base, alphaMult * b);
            GL11.glTexCoord2f(texOffset + fadeInTex + texPlus, 0 + bit);
            GL11.glVertex2f(-fadeInPortion * lMult, -w/2f * wMult);
            GL11.glTexCoord2f(texOffset + fadeInTex + texPlus, 1 - bit);
            GL11.glVertex2f(-fadeInPortion * lMult, w/2f * wMult);
            
            Misc.setColor(dim, alphaMult * b);
            GL11.glTexCoord2f(texOffset + flameTexSpan + texPlus, 0 + bit);
            GL11.glVertex2f(-len * lMult, -w/2f * wMult);
            GL11.glTexCoord2f(texOffset + flameTexSpan + texPlus, 1 - bit);
            GL11.glVertex2f(-len * lMult, w/2f * wMult);
            GL11.glEnd();
        }
        
    }
    
    
    protected void renderGlow(float alphaMult) {
        float w = glowSize;
        float h = glowSize;
        
        float glowScale = main.getGlowMult().getCurr();
        //glowScale = 0.1f;
        float fringeScale = glowScale * main.getGlowFringeMult().getCurr();
        float coreScale = glowScale * main.getGlowCoreMult().getCurr();
        
        
        if (glowScale <= 0f) return;
        
        Color fringeColor = main.getGlowColorFringe().getCurr();
        if (fringe != null) fringeColor = fringe;
        
        Color coreColor = main.getGlowColorCore().getCurr();
        if (core != null) coreColor = core;
        
        glow.setColor(fringeColor);
        glow.setAdditiveBlend();
        
        glow.setAlphaMult(alphaMult * 0.5f);
        glow.setSize(w * fringeScale, h * fringeScale);
        glow.renderAtCenter(0f, 0f);
        
        glow.setColor(coreColor);
        //for (int i = 0; i < 5; i++) {
        for (int i = 0; i < 2; i++) {
            w *= 0.3f;
            h *= 0.3f;
            glow.setSize(w * coreScale, h * coreScale);
            glow.setAlphaMult(alphaMult * 0.67f);
            glow.renderAtCenter(0f, 0f);
        }
    }
    
 
    public float getAngle() {
        return angle;
    }
 
    public void setAngle(float angle) {
        this.angle = angle;
    }
 
    public float getLength() {
        return length;
    }
 
    public void setLength(float length) {
        this.length = length;
    }
 
    public float getGlowSize() {
        return glowSize;
    }
 
    public void setGlowSize(float glowSize) {
        this.glowSize = glowSize;
    }
 
    public float getWidth() {
        return width;
    }
 
    public void setWidth(float width) {
        this.width = width;
    }
 
    public Vector2f getOffset() {
        return offset;
    }
 
    public void setOffset(Vector2f offset) {
        this.offset = offset;
    }
 
    public Color getFringe() {
        return fringe;
    }
 
    public void setFringe(Color fringe) {
        this.fringe = fringe;
    }
 
    public Color getCore() {
        return core;
    }
 
    public void setCore(Color core) {
        this.core = core;
    }
 
    public CampaignEngineGlowUtil getMain() {
        return main;
    }
 
    public void setMain(CampaignEngineGlowUtil main) {
        this.main = main;
    }
 
    public SpriteAPI getGlow() {
        return glow;
    }
 
    public void setGlow(SpriteAPI glow) {
        this.glow = glow;
    }
 
    public FaderUtil getFader() {
        return fader;
    }
 
    public Color getFlameColor() {
        return flameColor;
    }
 
    public void setFlameColor(Color flameColor) {
        this.flameColor = flameColor;
    }
 
    public float getFlameTexSpanMult() {
        return flameTexSpanMult;
    }
 
    public void setFlameTexSpanMult(float flameTexSpanMult) {
        this.flameTexSpanMult = flameTexSpanMult;
    }
    
    
}