Death Star: Difference between revisions

{{task|Constructive Solid Geometry}}{{requires|Graphics}}[[Category:Geometric Subtraction]]

<langsyntaxhighlight lang="brlcad"># We need a database to hold the objects

rt</langsyntaxhighlight>

<langsyntaxhighlight lang="c">#include <stdio.h>

const char *shades[] = ".:!*oe&#%@";

double light[3] = { -50, 300, 50 };

for (i = floor(bigpos.cy - bigpos.r); i <= ceil(bigpos.cy + bigpos.r); i++) {

for (j = floor(bigpos.cx - 2 * bigpos.r); j <= ceil(bigpos.cx + 2 * bigpos.r); j++) {

x = (j - bigpos.cx) / 2. + .5 + bigpos.cx;

if (!hit_sphere(&bigpos, x, y, &zb1, &zb2))

/* ray hits bigpos sphere but not small oneneg, draw bigpos sphere surface */

else if (!hit_sphere(&smallneg, x, y, &zs1, &zs2))

/* ray hits both, but smallpos front surface is obscured by bigcloser */

else if (zs1 > zb1) hit_result = 1;

/* bothpos largesphere pointssurface entirelyis inside smallneg sphere, show bg */

else if (zs2 > zb2) hit_result = 0;

/* ifback deeper intersectionsurface on smallneg sphere is inside bigpos sphere,

the only place where smallneg sphere surface will be shown */

else if (zs2 > zb1) hit_result = 2;

else hit_result = 1;

putchar(' +');

vec[0] = x - bigpos.cx;

vec[1] = y - bigpos.cy;

vec[2] = zb1 - bigpos.cz;

vec[0] = smallneg.cx - x;

vec[1] = smallneg.cy - y;

vec[2] = smallneg.cz - zs2;

<langsyntaxhighlight lang="d">import std.stdio, std.math, std.numeric, std.algorithm;

/*const*/ struct V3 {

@property V3 normalize() pure nothrow const @nogc {

//immutable double len = sqrt(dotProduct(v, v)).sqrt;

immutablereturn double len= sqrt(v[0]*v[0]+ / len, v[1]*v[1]+ / len, v[2]*v[2 / len]).V3;

double dot(constin ref V3 y) pure nothrow const @nogc {

void drawSphere(in double k, in double ambient, in V3 light) nothrow {

return the intersecting z values. z1 is closer to the eye .*/

static bool hitSphere(constin ref Sphere sph,

out double z2) pure nothrow @nogc {

immutable double szsq = sqrt(zsq).sqrt;

enum stringimmutable shades = ".:!*oe&#%@";

enumimmutable smallpos = Sphere(720, 720, -100, 1520);

foreach (immutable int i; cast(int)floor(bigpos.cy - bigpos.r) ..

cast(int)ceil(bigpos.cy + bigpos.r) + 1) {

jloopJLOOP:

foreach (int j; cast(int)floor(bigpos.cx - 2 * bigpos.r) ..

cast(int)ceil(bigpos.cx + 2 * bigpos.r) + 1) {

immutable double x = (j - bigpos.cx) / 2.0 + 0.5 + bigpos.cx;

immutable Hit hitResult = {

if (!hitSphere(pos, x, y, // ray lands in blank spacezb1, drawzb2)) bg{

hitResult// =Ray Hitlands in blank space, draw bg.background;

else if (!hitSphere(small, x, y,return zs1, zs2))Hit.background;

} else if (!hitSphere(neg, //x, rayy, hitszs1, bigzs2)) sphere but not small one,{

// drawRay bighits pos sphere surfacebut not neg one,

hitResult// =draw Hitpos sphere surface.bigSphere;

else if (zs1 > zb1)return Hit.posSphere;

} else if (zs1 //> rayzb1) hits both, but small surface if{

// obscuredray byhits bigboth, but pos front surface is closer.

hitResult =return Hit.bigSphereposSphere;

} else if (zs2 > zb1zb2) {

// ifpos deepersphere intersectionsurface onis smallinside shpereneg issphere,

// insideshow big sphere, only place where smallbg.

//return sphere surface will be shownHit.background;

} else if (zs2 hitResult> =zb1) Hit.smallSphere;{

else // Back surface on neg sphere is inside pos

hitResult// =sphere, Hit.bigSphere;the only place where neg sphere

} // surface will be shown.

putchar(' ').putchar;

continue jloopJLOOP;

case Hit.bigSphereposSphere:

vec_ = V3([x - bigpos.cx, y - bigpos.cy, zb1 - bigpos.cz]).V3;

case Hit.smallSpherenegSphere:

vec_ = V3([smallneg.cx - x, smallneg.cy - y, smallneg.cz - zs2]).V3;

immutable V3 nvec = vec_.normalize;

ifimmutable (intensitynormInt <= min(shades.length, max(0, intensity));

putchar(shades[0normInt]).putchar;

putchar('\n').putchar;

enumimmutable light = V3([-50, 30, 50]).V3.normalize;

}</langsyntaxhighlight>

<langsyntaxhighlight lang="delphi">const cShades = '.:!*oe&#%@';

DrawSphere(2, 0.3);</langsyntaxhighlight>

<langsyntaxhighlight lang="perl">use strict;

my $bigpos = [ 120, 120, 0, 120 ];

my $sm neg = [ 27-77, 67-33, -90100, 80190 ];

my $light = normalize([ 120-12, -13013, -15010 ]);

print "P5\n", $bigpos->[0] * 2 + 3, " ", $bigpos->[1] * 2 + 3, "\n255\n";

for my $y (($bigpos->[1] - $bigpos->[3] - 1) .. ($bigpos->[1] + $bigpos->[3] + 1)) {

for my $x (($bigpos->[0] - $bigpos->[3] - 1) .. ($bigpos->[0] + $bigpos->[3] + 1)) {

my @h = hit($bigpos, $x, $y);

elsif (!(@hs = hit($smneg, $x, $y))) { $hit = 1 }

$v = [ $x - $bigpos->[0],

$y - $bigpos->[1],

$h[0] - $bigpos->[2] ];

$v = [ $smneg->[0] - $x,

$smneg->[1] - $y,

$smneg->[2] - $hs[1] ];

draw(42, 0.2);</langsyntaxhighlight>

<syntaxhighlight lang="raku" perl6line>class sphere {

my $xwidth = my $yheight = 255; # dimensions of generated .pgm; must be odd

my $s = ($xwidth - 1)/2; # scaled dimension to build geometry

my @light = normalize([ -24, 4-1, -53 ]);

# largepositive sphere at origin

my $lgpos = sphere.new(

# smallnegative sphere offset to upper left

my $smneg = sphere.new(

cx => (-$s*.6590).Int,

cy => (-$s*.6590).Int,

cz => (-$s*.53).Int,

r => ($s*.57).Int

my $out = open(spurt $outfile, :w, :bin ) or die ("P5\n$width $!height\n$depth\n"); # .pgm header

my $out.say = open("P5\n$x $y\n$depth"outfile, :a, :bin ); #orelse .pgm headerdie;

say 'Calculating row:Working...';

$out.printwrite( Blob.new( |draw_ds(3, .15)».chrs ) );

my @pixels[$height];

for (($lgpos.cy - $lgpos.r) .. ($lgpos.cy + $lgpos.r)).race.map: -> $y {

printmy @row[$bs, $y, ' 'width]; # monitor progress

for (($lgpos.cx - $lgpos.r) .. ($lgpos.cx + $lgpos.r)).map: -> $x {

# black if we don't hit largepositive sphere, ignore smallnegative sphere

if not hit($lgpos, $x, $y, my $lgzposz) {

@pixels.push(row[$x + $s] = 0);

next;

}

# is front of largepositive sphere inside smallnegative sphere?

if hit($smneg, $x, $y, my $smznegz) and $smznegz.min < $lgzposz.min < $smznegz.max {

# make black if whole largepositive sphere eaten here

if $smznegz.min < $lgzposz.max < $smznegz.max { @pixels.push(row[$x + $s] = 0); next; }

# render inside of smallnegative sphere

@vec = normalize([$smneg.cx - $x, $smneg.cy - $y, -$smznegz.max - $smneg.cz]);

@pixels.push(row[$x + $s] = ($intensity * $depth).Int min $depth );

sayflat $bs, 'Writing|@pixels.map: file*.'list;

sub normalize (@vec) { return @vec »/» ([+] @vec Z»*« @vec).sqrt }

sub dot (@x, @y) { return -([+] @x Z»*« @y) max 0 }

return 0False if $z2 < 0;

return 1True;

}</langsyntaxhighlight>

=={{header|OpenscadREXX}}==

set ! }32

=={{header|POV-RaySidef}}==