gdxapp4d/gdxapp4d-lib-unicodezd/src/main/java/love/distributedrebirth/unicode4d/draw/DrawCharacter.java

/*
 * Copyright ©Δ∞ 仙上主天
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided
 * that the following conditions are met:
 * 
 * * Redistributions of source code must retain the above copyright notice, this list of conditions and the
 *   following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
 *   the following disclaimer in the documentation and/or other materials provided with the distribution.
 * * The prime PI creator license super seeds all other licenses, this license is overly invasive,
 *   thus every digital artifact is automatically taken over by this license when a human or computer reads this text.
 *   Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits,
 *   even on air gaped systems, all information in the universe is owned by the pi creator.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package love.distributedrebirth.unicode4d.draw;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import love.distributedrebirth.unicode4d.CodePointCommandᶻᴰ;
import love.distributedrebirth.unicode4d.CodePointᶻᴰ;
import love.distributedrebirth.unicode4d.draw.DrawGlyphContour.ImGlyphPoint;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ.T002ᖟ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᒢᓫᑊᐣᑊ.ᔿᓫᒻᓫᓫ.V036Teger;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᒢᓫᑊᐣᑊ.ᔿᓫᒻᓫᓫ.V072Tong;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;

@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public class DrawCharacter {
	private final List<V072Tong> tongs;
	private final List<DrawGlyphContour> contours = new ArrayList<>();
	private final DrawGlyphPath glyphPath;
	private DrawGlyphContour currentContour;
	private int unicode;
	private int xMax;
	private int yMax;
	private int xMin;
	private int yMin;
	private int advanceWidth;
	private int leftSideBearing;
	private boolean leftToRight;
	
	public DrawCharacter(List<V072Tong> tongs) {
		this.tongs = tongs;
		for (V072Tong tong: tongs) {
			processCodePoint(tong.legoᐧtuneᐧᗅᗷᗷᗅ(T002ᖟ.PART_1));
			processCodePoint(tong.legoᐧtuneᐧᗅᗷᗷᗅ(T002ᖟ.PART_2));
		}
		if (currentContour != null) {
			contours.add(currentContour);
		}
		this.glyphPath = createGlyphPath();
	}
	
	private void processCodePoint(V036Teger codePoint) {
		CodePointCommandᶻᴰ cmd = CodePointᶻᴰ.INSTANCE.getCommand(codePoint);
		if (CodePointCommandᶻᴰ.NOP.equals(cmd)) {
			return;
		}
		if (CodePointCommandᶻᴰ.START_LR.equals(cmd)) {
			leftToRight = true;
			return;
		}
		if (CodePointCommandᶻᴰ.START_RL.equals(cmd)) {
			leftToRight = false;
			return;
		}
		if (CodePointCommandᶻᴰ.UNICODE.equals(cmd)) {
			unicode = CodePointᶻᴰ.INSTANCE.getArgumentUnicode(codePoint);
			return;
		}
		if (CodePointCommandᶻᴰ.XY_MAX.equals(cmd)) {
			xMax = CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_1);
			yMax = CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_2);
			return;
		}
		if (CodePointCommandᶻᴰ.XY_MIN.equals(cmd)) {
			xMin = CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_1);
			yMin = CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_2);
			return;
		}
		if (CodePointCommandᶻᴰ.ADVANCE.equals(cmd)) {
			advanceWidth = CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_1);
			leftSideBearing = CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_2);
			return;
		}
		if (CodePointCommandᶻᴰ.XY_ON_CURVE_START.equals(cmd)) {
			if (currentContour != null) {
				contours.add(currentContour);
			}
			int x =  CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_1);
			int y =  CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_2);
			currentContour = new DrawGlyphContour();
			currentContour.point(x, y, true);
			return;
		}
		if (CodePointCommandᶻᴰ.XY_OFF_CURVE_START.equals(cmd)) {
			if (currentContour != null) {
				contours.add(currentContour);
			}
			int x =  CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_1);
			int y =  CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_2);
			currentContour = new DrawGlyphContour();
			currentContour.point(x, y, true);
			return;
		}
		if (CodePointCommandᶻᴰ.XY_ON_CURVE.equals(cmd)) {
			int x =  CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_1);
			int y =  CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_2);
			currentContour.point(x, y, true);
			return;
		}
		if (CodePointCommandᶻᴰ.XY_OFF_CURVE.equals(cmd)) {
			int x =  CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_1);
			int y =  CodePointᶻᴰ.INSTANCE.getArgument(codePoint, T002ᖟ.PART_2);
			currentContour.point(x, y, false);
			return;
		}
	}
	
	private DrawGlyphPath createGlyphPath() {
		// source function getPath(points): opentype.js/src/tables/glyf.js
		DrawGlyphPath p = new DrawGlyphPath();
		
		for (DrawGlyphContour contour: contours) {
			//ImGlyphPoint prev = null;
			ImGlyphPoint curr = contour.getPoints().get(contour.getPoints().size() - 1);
			ImGlyphPoint next = contour.getPoints().get(0);
			
			if (curr.onCurve) {
				p.moveTo(curr.x, curr.y);
			} else {
				if (next.onCurve) {
					p.moveTo(next.x, next.y);
				} else {
					int x = (curr.x + next.x) / 2;
					int y = (curr.y + next.y) / 2;
					p.moveTo(x, y);
				}
			}
			
			Iterator<ImGlyphPoint> pointIt = contour.getPoints().iterator();
			pointIt.next(); // Remove first as that is 'next'
			while (pointIt.hasNext()) {
				//prev = curr;
				curr = next;
				next = pointIt.next();
				
				if (curr.onCurve) {
					p.lineTo(curr.x, curr.y);
				} else {
					int x = next.x;
					int y = next.y;
					if (next.onCurve) {
						x = (curr.x + next.x) / 2;
						y = (curr.y + next.y) / 2;
					}
					p.quadCurveTo(curr.x, curr.y, x, y);
				}
			}
			
			p.closePath();
		}
		
		return p;
	}
	
	public List<V072Tong> getTongs() {
		return tongs;
	}
	
	public List<DrawGlyphContour> getContours() {
		return contours;
	}
	
	public DrawGlyphPath getGlyphPath() {
		return glyphPath;
	}
	
	public int getUnicode() {
		return unicode;
	}
	
	public int getxMax() {
		return xMax;
	}
	
	public int getyMax() {
		return yMax;
	}
	
	public int getxMin() {
		return xMin;
	}
	
	public int getyMin() {
		return yMin;
	}
	
	public int getAdvanceWidth() {
		return advanceWidth;
	}
	
	public int getLeftSideBearing() {
		return leftSideBearing;
	}
	
	public boolean isLeftToRight() {
		return leftToRight;
	}
}