Draw a sphere: Difference between revisions

 

 

=={{header|Ada}}==

Uses the Cairo component of GtkAda to create and save as png

[[File:SphereAda.png|thumb|right]]

with Cairo; use Cairo;

with Cairo.Png; use Cairo.Png;

Status_Out := Write_To_Png (Surface, "SphereAda.png");

pragma Assert (Status_Out = Cairo_Status_Success);

 

{{libheader|Display}}

This uses a very loose binding to SDL as found in any GPS installation. For it to work, you must choose New Project From Templte|Empty Game

 

with Display; use Display;

with Display.Basic; use Display.Basic;

null;

end Main;

 

=={{header|AutoHotkey}}==

{{libheader|GDIP}}

SetBatchLines, -1

#SingleInstance, Force

; gdi+ may now be shutdown on exiting the program

Gdip_Shutdown(pToken)

 

 

 

 

 

 

{{works with|BBC BASIC for Windows}}

Using Direct3D.

INSTALL @lib$+"D3DLIB"

D3DTS_VIEW = 2

SYS "FreeLibrary", d3dx%

END

[[File:Sphere_BBC.jpeg]]

 

=={{header|Brlcad}}==

 

units cm # Set the unit of measure

 

=={{header|C}}==

The lighting calculation is somewhere between crude and bogus, but hey, I'm shading it with ASCII characters, don't expect too much.

#include <stdlib.h>

#include <string.h>

 

return 0;

##&&eeeeeeeeee&&&&&&&####%%%%%%%%

&&eeooooooooooooooeeeee&&&&######%%%%%%%%

eeeeeeeeeeeeeeeeeeeeeeeeeeeee

eeeeeeeeeeeeeeeeeeeee

 

===Fun with 3D noise texture===

[[file:sphere-perlin.png]]

#include <stdlib.h>

#include <math.h>

int g[] = { -1, 1, -1, 1 };

/* Perlin-like noise */

hashed(int *data, int *out, int len) {

# define ror(a, d) ((a << (d)) | (a >> (32 - d)))

 

return 0;

 

=={{header|C sharp|C#}}==

{{trans|C}}

 

namespace Sphere {

}

}

 

=={{header|Clojure}}==

{{libheader|quil}}

(use 'quil.core)

 

:draw draw

:renderer :opengl)

 

{{out}}

[http://i.imgur.com/fkzH5wM.png]

 

=={{header|D}}==

{{trans|C}}

 

alias V3 = double[3];

drawSphere(20, 4, 0.1);

drawSphere(10, 2, 0.4);

 

=={{header|Delphi}}==

'''Steps:''' Run the CMD Windows shell. Then follow this path to setup the new width: '''Main Menu-> Properties -> Layout -> Window Size -> Width'''.

 

program DrawASphere;

 

Readln;

end.

 

<pre>

&&&&&&&&&&#######

[[image:DWScript-sphere.pbm.png|thumb|right|PBM output magnified 5 times]]

{{trans|C}} but adapted to spit out a [[wp:Netpbm_format|PGM]] image

type

TFloat3 = array[0..2] of Float;

normalize(light);

drawSphere(19, 4, 0.1);

=={{header|Go}}==

[[file:GoSphere.png|right|thumb|Output png]]

{{trans|C}}

Using image library rather than ASCII art.

 

import (

fmt.Println(err)

}

 

=={{header|Haskell}}==

[[File:Sphere_Haskell.png|thumb|right]]

import Graphics.UI.GLUT.Objects

import Graphics.UI.GLUT

setMaterial

displayCallback $= display

 

==Icon and {{header|Unicon}}==

Unicon provides a built-in interface to openGL including some higher level abstractions (for more information see [[Icon%2BUnicon/Intro#Graphics.2C_Network_Messaging.2C_etc.|Unicon Technical References, 3D Graphics]]). The example below draws a blue sphere on a black background and waits for input to quit.[[File:Sphere_unicon.PNG|thumb|Unicon Sphere]]

 

W := open("Demo", "gl", "size=400,400", "bg=black") | stop("can't open window!")

WAttrib(W, "slices=40", "rings=40", "light0=on, ambient white; diffuse gold; specular gold; position 5, 0, 0" )

DrawSphere(W, 0, 0, -5, 1)

Event(W)

 

=={{header|J}}==

[[File:J-sphere.png|thumb|J Sphere]]

 

> sphere [Run]

 

<div style="border: 1px solid #000000; overflow: auto; width: 100%"></div>

 

===Raytracing Solution===

Here's a version using raytracing computed in J. luminosity is an array of luminosity values with theoretical maximum 1 and minimum 0, and viewmat is used to display this.

 

light =. (% +/&.:*:) 30 30 _50

pts =. (0&*^:(0={:))@:(,,(0>.(*:R)-+)&.*:)"0/~ i:15j200

 

load 'viewmat'

 

=={{header|Java}}==

{{trans|C}}

static char[] shades = {'.', ':', '!', '*', 'o', 'e', '&', '#', '%', '@'};

 

drawSphere(10, 2, .4);

}

<pre> &&&&&&&&&&#######

&eeeeeeeeeeeeeeee&&&&&&#######%

eeeeeeeeeeeee

</pre>

=={{header|JavaScript}}==

 

This Javascript entry uses an HTML wrapper to offer easy running and some interactivity. It is made as such, though, that the entire HTML wrapper can be removed (except for a canvas with id <code>c</code>) and still work. If you remove the HTML, call the <code>draw_sphere</code> function to draw the thing.

 

<html>

<head>

<canvas id="c">Unsupportive browser...</canvas><br>

</body>

 

 

 

 

 

 

 

 

 

 

=={{header|Lua}}==

{{trans|C}}

{{works with|Lua|5.1.4}}

 

shades = {'.', ':', '!', '*', 'o', 'e', '&', '#', '%', '@'}

 

draw_sphere (20, 4, 0.1)

<pre> &&&&&&&&&&&&#####

&eeeoooooooooeeeeee&&&&&#######

eeeeeeeeeeeee

</pre>

Mathematica has many 3D drawing capabilities. To create a sphere with radius one centered at (0,0,0):

 

=={{header|Maxima}}==

plot3d(1, [theta, 0, %pi], [phi, 0, 2 * %pi],

[transform_xy, spherical_to_xyz], [grid, 30, 60],

sin(phi)*sin(theta),

cos(theta),

 

{{trans|C}}

 

type Point = tuple[x,y,z: float]

let light = normalize(30.0, 30.0, -50.0)

 

for i in -r .. r:

let x = i.float + 0.5

 

drawSphere 20, 4.0, 0.1

<pre> &&&&&&&&&&#######

&eeeeeeeeeeeeeeee&&&&&&#######%

eeeeeeeeeeeeeeeeeeeee

eeeeeeeeeeeee</pre>

 

=={{header|Openscad}}==

Drawing a sphere is easy in openscad:

 

 

[[Category:Geometric Primitives]]

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

After changing "{$APPTYPE CONSOLE}" to "{$mode delphi}" or "{$mode objfpc}" the Delphi example works with FreePascal.

 

=={{header|Perl}}==

 

 

use warnings;

 

},

q{""} => sub { sprintf "Vector:[%s]", join ' ', @{shift()} };

 

 

=={{header|PicoLisp}}==

{{libheader|GLUT}}

This is for the 64-bit version.

 

(glutInit)

# Exit upon mouse click

(mouseFunc '((Btn State X Y) (bye)))

 

{{trans|C}}

 

 

(setq *Shades

(setq *Light (normalize *Light))

(drawSphere 20.0 4 0.1)

<pre> ##############%%%

#&&eeeeeeeeeee&&&&&&######%%%%%

=={{header|PostScript}}==

Gradient filled circle:

%%BoundingBox 0 0 300 300

 

showpage

%%EOF

 

=={{header|POV-Ray}}==

This is what POVray was made for. An example with a sky, surface and transparency:

 

camera { location <0.0 , .8 ,-3.0> look_at 0}

interior { ior 1.5}

}

 

Yields this:

3D rendering is built into Processing.

 

}

void draw() {

stroke(200);

lights();

 

 

 

 

 

=={{header|Python}}==

{{trans|C}}

 

shades = ('.',':','!','*','o','e','&','#','%','@')

light = normalize((30,30,-50))

draw_sphere(20,4,0.1, light)

<pre> &&&&&&&&&&######

&&eeeeeeeeeeeeeeee&&&&&&######%%

</pre>

 

import pygame

from pygame.locals import *

import random

import math

class Tricubic:

def __init__(self,pts):

if event.type == KEYDOWN:

pass

 

=={{header|Racket}}==

Using the Typed Racket language with the plot library:

 

#lang typed/racket

 

(require plot/typed)

(plot3d (polar3d (λ (θ ρ) 1)) #:altitude 25)

 

=={{header|REXX}}==

This program is modeled after the &nbsp; '''C''' &nbsp; version.

<br>Same with the &nbsp; '''CEIL'''ing &nbsp; and &nbsp; '''FLOOR''' &nbsp; functions.

 

eeeeeeeeee@@@@@@@

eoooooooooooooooeeeee@@@@@@@░

Shoes comes with this sample program.

[[File:sphere.shoes.png|thumb|right]]

image 400, 470, :top => 30, :left => 50 do

nostroke

end

end

 

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

although there is a Point3 class in some loadable library, here is some self contained code, defining a local anon Point3D class.

Point3D :=

Point subclass:#Point3D

 

main value.

[[file:sphere-smalltalk.png]]

 

Not quite a sphere.

[[file:sphere-ish.svg]]

 

=={{header|Tcl}}==

Assuming the task is to draw a <i>likeness</i> of a sphere, this would usually do:

 

 

pack [canvas .c -height 400 -width 640 -background white]

set h [grey $i]

.c create arc [expr {100+$i/5}] [expr {50+$i/5}] [expr {400-$i/1.5}] [expr {350-$i/1.5}] \

Results in this image:

 

[[image:Tcl-spheroid.gif]]