summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.gitignore1
-rw-r--r--.project1
-rw-r--r--build.sbt3
-rw-r--r--src/Math.scala14
-rw-r--r--src/Objects.scala151
-rw-r--r--src/Scene.scala152
-rw-r--r--src/main.scala40
-rw-r--r--src/test.scala3
8 files changed, 365 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..eb5a316
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+target
diff --git a/.project b/.project
new file mode 100644
index 0000000..6550b29
--- /dev/null
+++ b/.project
@@ -0,0 +1 @@
+project_name="raytrace"
diff --git a/build.sbt b/build.sbt
new file mode 100644
index 0000000..d52ea1b
--- /dev/null
+++ b/build.sbt
@@ -0,0 +1,3 @@
+name := "DIFFS LOL"
+
+scalaSource in Compile := baseDirectory.value / "src"
diff --git a/src/Math.scala b/src/Math.scala
new file mode 100644
index 0000000..601e457
--- /dev/null
+++ b/src/Math.scala
@@ -0,0 +1,14 @@
+package net.iximeow.raytrace
+
+import Objects._
+
+object Raymath {
+ def angleBetween(a: Point, b: Point, c: Point): Double = {
+ val lineA = a - b
+ val lineB = c - b
+ Math.acos(lineA.dot(lineB) / (lineA.magnitude * lineB.magnitude))
+ }
+
+ def toDegrees(rad: Double): Double = rad * 360 / 2 / Math.PI
+ def toRadians(deg: Double): Double = deg / 360 * 2 * Math.PI
+}
diff --git a/src/Objects.scala b/src/Objects.scala
new file mode 100644
index 0000000..b4e6435
--- /dev/null
+++ b/src/Objects.scala
@@ -0,0 +1,151 @@
+package net.iximeow.raytrace
+
+import java.awt.image.BufferedImage
+
+object Objects {
+ /*
+ * 3d nah
+ case class Point(x: Double, y: Double, z: Double)
+ case class Plane(pitch: Double, roll: Double, altitude: Double)
+ case class BoundedPlane(pitch: Double, roll: Double, center: Point, h: Point, w: Point)
+ */
+
+ case class Point(x: Double, y: Double) {
+ def +(other: Point): Point = Point(x + other.x, y + other.y)
+ def -(other: Point): Point = Point(x - other.x, y - other.y)
+ def /(scale: Double): Point = Point(x / scale, y / scale)
+ def *(scale: Double): Point = Point(x * scale, y * scale)
+ def magnitude: Double = distTo(Point.Zero)
+ def distTo(other: Point) = Math.sqrt(sqDistTo(other))
+ def sqDistTo(other: Point) = (other.x - x) * (other.x - x) + (other.y - y) * (other.y - y)
+ def dot(other: Point): Double = x * other.x + y * other.y
+ }
+ object Point {
+ val Zero = Point(0, 0)
+ }
+ case class Line(m: Double, b: Double)
+ object Line {
+ def fromPoints(p1: Point, p2: Point): Line = {
+ val m = (p2.y - p1.y) / (p2.x - p1.x)
+ val b = p1.y - m*p1.x
+ Line(m, b)
+ }
+ }
+ /*
+ * Segments are defined for t in [0, 1]
+ */
+ case class Segment(x: Double, y: Double, initial: Point) {
+ def at(t: Double): Point = Point(x * t, y * t) + initial
+ def apply = at _
+ def length = Math.sqrt(x * x + y * y)
+ def intersect(other: Segment): Double = {
+ /*
+ * P1 = ai + t * a
+ * P2 = bi + u * b
+ * P1 == P2, so
+ * ai + t * a = bi + u * b
+ * ...
+ * ai.x + t * a.x = bi.x + u * b.x
+ * ai.y + t * a.y = bi.y + u * b.y
+ * t = (bi.x + u * b.x - ai.x) / a.x
+ * ai.y + a.y * (bi.x + u * b.x - ai.x) / a.x = bi.y + u * b.y
+ * ai.y + a.y * bi.x / a.x + u * b.x * a.y / a.x - ai.x * a.y / a.x = bi.y + u * b.y
+ * ai.y - bi.y + (a.y / a.x) (bi.x - ai.x) = u * b.y - u * b.x * a.y / a.x
+ * ai.y - bi.y + (a.y / a.x) (bi.x - ai.x) / (b.y - b.x * a.y / a.x) = u
+ *
+ * (a.x * (ai.y - bi.y) + a.y * (bi.x - ai.x)) / (b.y - b.x * a.y)
+ */
+ val u = (
+ x * (initial.y - other.initial.y) +
+ y * (other.initial.x - initial.x)
+ ) / (
+ other.y * x - other.x * y
+ )
+
+ u
+ }
+
+ def intersectChecked(other: Segment): Option[Point] = {
+ val u = intersect(other)
+ if (u >= 0 && u <= 1) {
+ //println("Intersection is at u=" + u)
+
+ Some(other.at(u))
+ } else {
+ None
+ }
+ }
+ def tFor(p: Point): Option[Double] = {
+ (x, y) match {
+ case (0, _) => Some((p.y - initial.y) / y)
+ case (_, 0) => Some((p.x - initial.x) / x)
+ case (_, _) => {
+ val xT = (p.x - initial.x) / x
+ val yT = (p.y - initial.y) / y
+ if (Math.abs(xT - yT) < 0.000001) {
+ Some(xT)
+ } else {
+ None
+ }
+ }
+ }
+ }
+ def rotate(angle: Double, about: Point = Point(0, 0)): Segment = {
+ val start = this.at(0)
+ val end = this.at(1)
+ val newStart = {
+ val offset = start - about
+ val m = offset.magnitude
+ val newAngle = Math.atan2(offset.y, offset.x) + angle
+ Point(Math.cos(newAngle) * m, Math.sin(newAngle) * m) + about
+ }
+ val newEnd = {
+ val offset = end - about
+ val m = offset.magnitude
+ val newAngle = Math.atan2(offset.y, offset.x) + angle
+ Point(Math.cos(newAngle) * m, Math.sin(newAngle) * m) + about
+ }
+ Segment.fromPoints(newStart, newEnd)
+ }
+ def renderTo(buf: BufferedImage, scale: Double = 1, xoff: Int = 0, yoff: Int = 0, color: Int = 0x808000): Unit = {
+ try {
+ for (i <- (0 to 100)) {
+ val point = this.at(i / 100.0)
+ buf.setRGB(Math.round((point.x * scale).toFloat) + xoff, Math.round((point.y * scale).toFloat) + yoff, color)
+ }
+ } catch {
+ case (x: ArrayIndexOutOfBoundsException) => { /* well, we're not properly rendering a region so uh just ignore the failure i guess lol */ }
+ }
+ }
+ def normal: Segment = {
+ val normalMag = Math.sqrt(x * x + y * y)
+ val finalNormMult = 1.5 / normalMag
+ Ray(-y * finalNormMult, x * finalNormMult, (at(0) + at(1)) / 2).toSegment
+ }
+ }
+ object Segment {
+ def fromPoints(p1: Point, p2: Point): Segment = {
+ val (x0, y0) = (p2.x - p1.x, p2.y - p1.y)
+ Segment(x0, y0, p1)
+ }
+ def fromPointWithAngle(p: Point, angle: Double): Segment = {
+ val (x0, y0) = (Math.cos(angle), Math.sin(angle))
+ Segment(x0, y0, p)
+ }
+ }
+ case class Ray(x: Double, y: Double, initial: Point) {
+ def toSegment: Segment = Segment(x, y, initial)
+ def endingAt(p: Point): Ray = {
+ val intersectAt = this.toSegment.tFor(p)
+ intersectAt.map(t =>
+ Ray(x * t, y * t, initial)
+ ).getOrElse(this)
+ }
+ def dot(other: Ray): Double = {
+ x * other.x + y * other.y
+ }
+ def mag: Double = {
+ Math.sqrt(x * x + y * y)
+ }
+ }
+}
diff --git a/src/Scene.scala b/src/Scene.scala
new file mode 100644
index 0000000..9b59f7b
--- /dev/null
+++ b/src/Scene.scala
@@ -0,0 +1,152 @@
+package net.iximeow.raytrace
+
+import Objects._
+
+import java.awt.image.BufferedImage
+import javax.imageio._
+import java.io.File
+
+case class Scene(walls: Seq[Segment]) {
+ val buffer = new BufferedImage(800, 600, BufferedImage.TYPE_INT_RGB)
+
+ def render(scale: Double = 1, xoff: Int = 0, yoff: Int = 0, color: Int = 0x808000, normals: Boolean = false): Unit = {
+ for (wall <- walls) {
+ wall.renderTo(buffer, scale, 400, 300, color = color)
+ }
+ for (wall <- walls) {
+ wall.normal.renderTo(buffer, scale, 400, 300, color = 0xc00000)
+ }
+ }
+
+ def save(path: String = "render.png"): Unit = {
+ ImageIO.write(buffer, "png", new File(path))
+ }
+
+ def cast(r: Ray, steps: Int): Seq[Segment] = {
+ (0 until steps).foldLeft(Seq.empty[Segment] -> r) { case (p: (Seq[Segment], Ray), i: Int) => {
+ val (prevRay, nextRay) = castSingle(p._2)
+ ((p._1 :+ prevRay.toSegment) -> nextRay): (Seq[Segment], Ray)
+ }}._1
+ }
+
+ def castSingle(r: Ray): (Ray, Ray) = {
+ val asSeg = r.toSegment
+
+ def reflect(firstIntersection: (Segment, Point)): (Ray, Ray) = {
+ val minAngle = {
+ val fromStart = Raymath.angleBetween(
+ r.initial,
+ firstIntersection._2,
+ firstIntersection._1.at(0)
+ )
+ val fromEnd = Raymath.angleBetween(
+ r.initial,
+ firstIntersection._2,
+ firstIntersection._1.at(1)
+ )
+
+ println("Fromstart: " + Raymath.toDegrees(fromStart))
+ println("Fromend: " + Raymath.toDegrees(fromEnd))
+
+ if (Math.abs(fromStart) < Math.PI / 2) {
+ fromStart
+ } else {
+ fromEnd
+ }
+
+ fromStart
+ }
+
+ val maxAngle = Math.PI - minAngle
+
+ val baseAngle = Math.atan2(firstIntersection._1.y, firstIntersection._1.x)
+ println("base angle: " + Raymath.toDegrees(baseAngle))
+
+ val reflectedAngle = baseAngle + minAngle
+
+ if (minAngle < 0 || minAngle > Math.PI * 2) {
+ println("lol")
+ (r.endingAt(firstIntersection._2), r.endingAt(firstIntersection._2)) //Ray(0, 0, firstIntersection._2))
+ } else {
+ val (x, y) = (
+ Math.cos(reflectedAngle) * 3,
+ Math.sin(reflectedAngle) * 3
+ )
+
+ // Sure hope this is right...
+ (r.endingAt(firstIntersection._2), Ray(x, y, firstIntersection._2))
+ }
+ }
+ val intersections: Seq[(Segment, Point)] = walls.flatMap(w => {
+ w.intersectChecked(asSeg)
+ .map(x => (w, x))
+ })
+ .filter { case (w: Segment, x: Point) => asSeg.tFor(x).map(_ > 0.0000001).getOrElse(false) }
+
+ def isBehind(start: Segment, wall: Segment): Boolean = {
+ val normal = Ray(-wall.y, wall.x, Point(0, 0))
+ val rebased = Ray(start.x, start.y, Point(0, 0))
+ val cosAngle = normal.dot(rebased) / (normal.mag * rebased.mag)
+ cosAngle > 0
+ }
+
+ val continuedIntersections = intersections
+ .filter(i => {
+ val otherT = i._1.tFor(i._2)
+ otherT.map(t => t >= 0 && t <= 1).getOrElse(true)
+ })
+
+ val stoppedIntersections = intersections
+ .filter(i => {
+ val otherT = i._1.tFor(i._2)
+ otherT.map(t => t >= 0 && t <= 1 && isBehind(asSeg, i._1)).getOrElse(false)
+ })
+
+ def fnMin(x: (Segment, Point), y: (Segment, Point)) = if (asSeg.tFor(x._2).get < asSeg.tFor(y._2).get) x else y
+ val firstStop: Option[(Segment, Point)] = stoppedIntersections.reduceOption(fnMin(_, _))
+ val firstReflect: Option[(Segment, Point)] = continuedIntersections.reduceOption(fnMin(_, _))
+
+ (firstStop, firstReflect) match {
+ case (None, None) =>
+ (r, Ray(r.x, r.y, r.toSegment.at(1)))
+ case (Some(stop), None) =>
+ (r.endingAt(stop._2), Ray(0, 0, r.initial))
+ case (None, Some(cont)) => reflect(cont)/* reflect */
+ case (Some(stop), Some(cont)) => {
+ if (fnMin(stop, cont) == stop) {
+ (r.endingAt(stop._2), Ray(0, 0, r.initial))
+ // stop
+ } else {
+ reflect(cont)
+ // reflect
+ }
+ }
+ }
+ }
+}
+
+object Scene {
+ def generateMirror(r: Double, segments: Int, arcSize: Double, at: Point, rotated: Double): Seq[Segment] = {
+ val sizePerSegment = arcSize / segments
+ val points = (0 to segments) map { i =>
+ val angle = i * sizePerSegment + rotated
+ at + Point(Math.cos(angle) * r, Math.sin(angle) * r)
+ }
+ points.sliding(2).map { case Seq(start, end) =>
+ Segment.fromPoints(start, end)
+ }.toSeq
+ }
+
+ def generateParabola(a: Double, b: Double, w: Double, w_i: Double, segments: Int, at: Point, rotated: Double): Seq[Segment] = {
+ val points = (-segments / 2 to segments / 2) map { i =>
+ val w_curr = (i / segments.toDouble) * w + w_i
+ at + Point(a * w_curr, b * w_curr * w_curr)
+ }
+ points.sliding(2).map { case Seq(start, end) =>
+ Segment.fromPoints(start, end)
+ }.toSeq
+ }
+
+ def rotate(walls: Seq[Segment], angle: Double) =
+ walls.map(_.rotate(angle))
+}
diff --git a/src/main.scala b/src/main.scala
new file mode 100644
index 0000000..8883cc7
--- /dev/null
+++ b/src/main.scala
@@ -0,0 +1,40 @@
+import net.iximeow.raytrace._
+import Objects._
+
+object main extends App {
+// val mirror = Scene(Scene.generateMirror(10, 60, Raymath.toRadians(180), Point(0, 0), 0))
+ val offset = Point(0.0, -9)
+ val mirror = Scene(Scene.generateParabola(-0.9, -0.0075, 16, 0, 42, Point(0, 14), 0) :+ Segment.fromPoints(
+ Point(-0.5, 0.5) + offset,
+ Point(0.5, -0.5) + offset
+ ))
+// val mirror = Scene(Seq(Segment(4, -4, Point(-2, 2))))
+ //val ray = mirror.cast(Ray(0, 2, Point(0.8, -1)), 4)
+ mirror.render(scale = 20, color = 0xc0c0c0, normals = true)
+ //for (segment <- ray) {
+ // segment.renderTo(mirror.buffer, 20, 400, 300)
+ //}
+/*
+ for (i <- -4 to 4 by 1) {
+ for (segment <- mirror.cast(Ray(i / 2.0, 2, Point(0.8, -1)), 4)) {
+ segment.renderTo(mirror.buffer, 20, 400, 300)
+ }
+ }
+*/
+ def rays(number: Int, spacing: Double, centerpoint: Point, direction: Point): Seq[Ray] = {
+ (0 until number).map { i =>
+ val x = (i.toDouble - number.toDouble / 2) * spacing
+ val y = 0
+ val dx = direction.x
+// * Math.cos((i.toDouble - number.toDouble) / (number.toDouble / 4))
+ val dy = direction.y
+ Ray(dx, dy, Point(x, y) + centerpoint)
+ }
+ }
+
+ rays(63, 0.165, Point(-0, -10), Point(0.0, 2))
+ .flatMap(x => mirror.cast(x, 30))
+ .map(_.renderTo(mirror.buffer, 20, 400, 300))
+ //println(ray)
+ mirror.save()
+}
diff --git a/src/test.scala b/src/test.scala
new file mode 100644
index 0000000..5780509
--- /dev/null
+++ b/src/test.scala
@@ -0,0 +1,3 @@
+object foo extends App {
+ println("hello world")
+}
generated by cgit v1.1 at 2024-12-03 17:10:55 +0000