Sorry your browser is not supported!

sync on : sync rate 0

irr init 1,640,480

mycube = iscn add cube node( 0, 10 )

mycam = iscn add camera node( 0 )
inode pos mycam,0,0,-15
icam target mycam,0,0,0

mylight = iscn add light node( 0 )
inode pos mylight,0,0,-15
ilight set radius mylight,50

myfont = igui get default font()


repeat
	
	inode rot mycube,angle#,angle#,0

	angle#=angle#+0.4
	if angle#>=360.0 then angle#=0.0
    
	irr begin scene 0x40, 0x00, 0x00, 0x80
	
	irr end scene
until irr keystate( 0x20 )

irr drop

IMAT DELETE material
IMAT NEW() return material
IMAT SET FLAG material,matflag,flag
IMAT GET FLAG(material,matflag) return flag
IMAT COPY material,srcmaterial
IMAT SET TEXTURE material,layer,texture
IMAT GET TEXTURE(material,layer) return texture
IMAT SET AMBIENT material, color
IMAT SET DIFFUSE material, color
IMAT SET EMISSIVE material, color
IMAT SET SPECULAR material, color
IMAT SET SHININESS material, color
IMAT SET PARAM1 material, param#
IMAT SET PARAM2 material, param#
IMAT SET THICKNESS material, thickness#
IMAT SET ZBUFFER material, flag
IMAT SET AA material, flag
IMAT SET COLOR MASK material, mask - 4 bits to the mask
IMAT SET COLOR MATERIAL material, cmaterial - 3 bits to the material
IMAT SET WIRE FRAME material, flag
IMAT SET POINT CLOUD material, flag
IMAT SET GORAUD SHADING material, flag
IMAT SET LIGHTING material, flag
IMAT SET ZWRITE material, flag
IMAT SET BACK FACE material, flag
IMAT SET FRONT FACE material, flag
IMAT SET FOG material, flag
IMAT SET NORMALIZE material, flag
IMAT SET TEXTURE WRAP material, layer, wrap
IMAT SET BILINEAR material, layer, flag
IMAT SET TRILINEAR material, layer, flag
IMAT SET ANISOTROPIC material, layer, flag
IMAT SET LOD BIAS material, layer, bias

` switch off most of DBP (well, just stop the auto syncing)
sync on

` open irrlichts window
irr init 1, 800, 600
idev set window caption "DarkIrrlicht for DBPro - Let's do something..."

` setup the dwarf
mesh_dwarf = iscn get mesh( "dwarf.x" )
node_dwarf = iscn add anim mesh node( 0, mesh_dwarf )
mat_dwarf = inode get material( node_dwarf, 0 )
imat set lighting mat_dwarf, 0
iamnode set speed node_dwarf, 15

` setup a cube for him to stand on
node_cube = iscn add cube node( 0, 50 )
texture_box = ivid get texture( "wall.jpg" )
inode material texture node_cube, 0, texture_box
inode pos node_cube, 0, -25, 0

` setup the skybox
img_bk = ivid get texture( "irrlicht2_bk.jpg" )
img_dn = ivid get texture( "irrlicht2_dn.jpg" )
img_ft = ivid get texture( "irrlicht2_ft.jpg" )
img_lf = ivid get texture( "irrlicht2_lf.jpg" )
img_rt = ivid get texture( "irrlicht2_rt.jpg" )
img_up = ivid get texture( "irrlicht2_up.jpg" )
node_skybox = iscn add skybox node( 0,img_up,img_dn,img_lf,img_rt,img_ft,img_bk )

` setup a scene camera
node_cam = iscn add camera node( 0 )
inode pos node_cam, 0, 40, -80
icam target node_cam, 0, 20, 0
cam_angle# = 0

` and give us light
node_light = iscn add light node( 0 )
inode pos node_light, -50, 50,-50
light_angle# = 0

` grab the default builtin font
font_default = igui get default font()

repeat
    ` this makes sure the animation runs smoothly
    idev timer tick
    ivid begin 1, 1, 0x7f0000
    
    ` rotate light around the scene
    inode pos node_light, cos( light_angle# ) * 50, 50, sin( light_angle# ) * 50
    light_angle# = wrapvalue( light_angle# + 0.75 )
    
    ` rotate camera around the scene
    inode pos node_cam, cos( cam_angle# ) * 80, 40, sin( cam_angle# ) * 80
    cam_angle# = wrapvalue( cam_angle# + 0.15 )
    
    ` draw all the 3d stuff 
    iscn draw all
    
    ` show the fps (after the 3d has been drawn)
    fps$ = "FPS : " + str$( ivid fps() )
    ifont draw font_default, 0, 0, 0xff000000, fps$
    
    ` end the scene and refresh the screen
    ivid end
until irr keystate( 0x20 )

` quit darkirrlicht
irr drop

Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Text

Imports IrrlichtLime
Imports IrrlichtLime.Core
Imports IrrlichtLime.Video
Imports IrrlichtLime.Scene
Imports IrrlichtLime.GUI

Module Module1

    Sub Main()
        Dim device As IrrlichtDevice = IrrlichtDevice.CreateDevice(DriverType.Software, New Dimension2Di(800, 600), 16, False, False, False)

        device.SetWindowCaption("Irrlicht Project!")

        Dim driver As VideoDriver = device.VideoDriver
        Dim smgr As SceneManager = device.SceneManager
        Dim gui As GUIEnvironment = device.GUIEnvironment



        Do While device.Run()
            driver.BeginScene(True, True, New Color(100, 101, 140))

            smgr.DrawAll()
            gui.DrawAll()

            driver.EndScene()
        Loop

        device.Drop()
    End Sub

End Module

INODE MATERIAL WIREFRAME==INODE MATERIAL WIREFRAME node,flag
INODE MATERIAL POINTCLOUD node,flag
INODE MATERIAL GORAUD node,flag
INODE MATERIAL LIGHTING node,flag
INODE MATERIAL ZBUFFER node,flag
INODE MATERIAL ZWRITE node,flag
INODE MATERIAL BACKFACE node,flag
INODE MATERIAL FRONTFACE node,flag
INODE MATERIAL BILINEAR node,flag
INODE MATERIAL TRILINEAR node,flag
INODE MATERIAL ANISOTROPIC node,flag
INODE MATERIAL FOG node,fog
INODE MATERIAL NORMALIZE node,flag
INODE MATERIAL TEXTUREWRAP node,flag
INODE MATERIAL ANTIALIASING node,flag
INODE MATERIAL COLORMASK node,flag
INODE MATERIAL COLORMATERIAL node,flag

` cause DBP to go to sleep for the duration

sync on : sync rate 60 : autocam off

` global variables

global imapmesh
global imapamesh
global mapnode
global fpscamnode
global lastfps
global fps

` set up irrlicht's window

irr init 1, 800, 600

` add the zip file to the file manager and load the quake level

if ifile add zip file archive("map-20kdm2.pk3",1,1) = 0 then end

imapmesh = iscn get mesh("20kdm2.bsp") : if imapmesh=0 then end

` add the map to the scene

imapamesh = iamesh get anim mesh(imapmesh,0,255,-1,-1) : if imapamesh=0 then end

mapnode = iscn add octree node(imapamesh,0,1024) : if mapnode=0 then end

inode pos mapnode,-1300,-144,-1249

` add the fps camera

fpscamnode = iscn add camera fps node()

irr hide mouse

` main loop

lastfps = -1

while idev run()
    if idev is window active()
        irr begin scene 0xffe0e0e0
        irr end scene
        
        fps = ivid fps()
        if fps<>lastfps
            s$ = "DarkIrrlicht - Quake 3 Map example [FPS: "
            s$ = s$ + str$(fps) + "]"
            idev set window caption s$
            lastfps = fps
        endif
    else
        idev yeild
    endif
endwhile

` keep DBP quiet for this

sync on

` start DarkIrrlicht

irr init 1,800,600

global node_sphere
global texture_wall
global node_cube
global texture_cube
global anim_temp
global mesh_ninja
global node_ninja
global cam_fps
global it_logo
global ie_logo
global ie_diag
global lastFPS
global fps
global time_then
global time_now
global MOVEMENT_SPEED#
global framedeltatime#

` create a textured sphere

node_sphere = iscn add sphere node(0,10,16)
inode pos node_sphere,0,0,30
texture_wall = ivid get texture("wall.bmp")
inode material texture node_sphere,0,texture_wall
inode material lighting node_sphere,0

` add an animated cube

node_cube = iscn add cube node(0,10)
texture_cube = ivid get texture("t351sml.jpg")
inode material texture node_cube,0,texture_cube
inode material lighting node_cube,0
anim_temp = ISCN CREATE FLY CIRCLE ANIM(0,0,30,20,1)
inode add animator node_cube,anim_temp
ianim drop anim_temp

` load up and animate a b3d model

mesh_ninja = iscn get mesh("ninja.b3d")
node_ninja = iscn add anim mesh node(0,mesh_ninja)
anim_temp = ISCN CREATE FLY STRAIGHT ANIM(100,0,60, -100,0,60, 3500, 1, 0)
inode add animator node_ninja,anim_temp
ianim drop anim_temp

inode material lighting node_ninja,0
inode set frame loop node_ninja,0,13
inode set anim speed node_ninja,15
inode set md2 run node_ninja

inode scale node_ninja,2,2,2
inode rot node_ninja,0,-90,0
inode material texture node_ninja,0,ivid get texture("sydney.bmp")

` camera and mouse

cam_fps = iscn add camera fps node()
irr hide mouse

` add a nice colourful logo

it_logo = ivid get texture("irrlichtlogoalpha2.tga")
ie_logo = IGUI ADD IMAGE(it_logo,10,20,1,0)

` this don't do much but it's part of the tut anyway

ie_diag = IGUI ADD STATIC TEXT("",10,10,400,20,0,1,0,0)
IGUI SET OVERRIDE COLOR ie_diag,0xffffff00

lastFPS = -1

time_then = idev get time()

MOVEMENT_SPEED# = 5.0

while idev run()
    ` work out delta time
    
    time_now = idev get time()
    framedeltatime# = ( time_now - time_then ) / 1000.0     ` time in seconds
    time_then = time_now
    
    x# = inode posx(node_sphere)
    y# = inode posy(node_sphere)
    z# = inode posz(node_sphere)
    
    if irr keystate(0x57)       ` W
        y# = y# + ( MOVEMENT_SPEED# * framedeltatime# )
    endif
    
    if irr keystate(0x53)       ` S
        y# = y# - ( MOVEMENT_SPEED# * framedeltatime# )
    endif
    
    if irr keystate(0x41)       ` A
        x# = x# + ( MOVEMENT_SPEED# * framedeltatime# )
    endif
    
    if irr keystate(0x44)       ` D
        x# = x# - ( MOVEMENT_SPEED# * framedeltatime# )
    endif
    
    inode pos node_sphere,x#,y#,z#
    
    irr begin scene 0xffa0a0a0
    irr end scene
    
    fps = ivid fps()
    
    if lastFPS <> fps
        s$ = "Movement example - DarkIrrlicht for DBPro [FPS: "
        s$ = s$ + str$(fps) + "]"
        idev set window caption s$
        lastFPS = fps
    endif
endwhile

irr drop

void demo_objects::generate(int size, int uvscale, int space)
{
	int	c,x,y;
	float	xx,yy,zz=0.0f;
	int	v1,v2,v3,v4,i;
	irr::video::S3DVertex	*v;
	irr::scene::SMeshBuffer	*buf;

	mesh	= new irr::scene::SMesh();
	buf	= new irr::scene::SMeshBuffer();

	mesh->addMeshBuffer(buf);
	buf->drop();	// still using the same pointer

	buf->Vertices.set_used( (uvscale+1) * (uvscale+1) );
	buf->Indices.set_used( uvscale * uvscale * 6 );

	for ( x=0; x<=uvscale; x++ )
	{
		for ( y=0; y<=uvscale; y++ )
		{
			v = &buf->Vertices[x+y*(uvscale+1)];
			xx=-((float)size/2.0f) + ((float)size/(float)(uvscale+1) * x);
            yy=-((float)size/2.0f) + ((float)size/(float)(uvscale+1) * y);
            v->Pos.set(xx,yy,zz);
            v->Normal.set(0.0f,0.0f,-1.0f);
            v->TCoords.set(x,y);
            v->Color=0xffffff;
            if (x<uvscale && y<uvscale)
			{
				v1=x+y*(uvscale+1);
				v2=v1+uvscale+1;
				v3=v2+1;
				v4=v1+1;
				i=(x+y*uvscale)*6;
				buf->Indices[i++]=v1;	// may need reversing ???
				buf->Indices[i++]=v2;
				buf->Indices[i++]=v3;
				buf->Indices[i++]=v3;
				buf->Indices[i++]=v4;
				buf->Indices[i]=v1;
			}
		}
	}
	buf->recalculateBoundingBox();
	for ( c=0; c<MAX_SETS*3; c++ )
	{
		set[c].angle = 0.0f;
		set[c].speed = c * 0.25f + 1.0f;
		set[c].pos   = space * c;
		set[c].node  = dirr.smgr->addMeshSceneNode(mesh);
		set[c].node->setMaterialTexture(0,gfx.textures[c%3]);
	}
}

` ------------------------------------------------------------------------------
` DarkIrrlicht SMesh & SMeshBuffer example
` I originally wrote this example on Linux using Irrlicht
` ------------------------------------------------------------------------------

` switch off DBP for now (only need to do the SYNC)

SYNC ON

` ------------------------------------------------------------------------------
` GLOBALS

` Delta timer to handle different frame rates smoothly

TYPE DELTA_TIMER
	told AS FLOAT
	tdel AS FLOAT
ENDTYPE
GLOBAL dtel AS DELTA_TIMER

` Images and textures

TYPE GFX_DATA
	color AS DWORD
	image AS DWORD
	texture AS DWORD
ENDTYPE
GLOBAL DIM gfx(2) AS GFX_DATA

` Camera and light

TYPE CAM_AND_LIGHT
	ang1 AS FLOAT
	ang2 AS FLOAT
	ang3 AS FLOAT
	cam AS DWORD
	light AS DWORD
ENDTYPE
GLOBAL cam AS CAM_AND_LIGHT
#CONSTANT cam_spd1 0.96
#CONSTANT cam_spd2 1.15
#CONSTANT cam_spd3 1.51
#CONSTANT cam_rad1 80.0
#CONSTANT cam_rad2 65.0
#CONSTANT cam_rad3 100.0
#CONSTANT cam_dst -105.0

` Cube node

GLOBAL cube_node AS DWORD
GLOBAL cube_ang AS INTEGER

` 3D plane objects

TYPE PLANE_OBJECT
	ang AS FLOAT
	spd AS FLOAT
	pos AS FLOAT
	node AS DWORD
ENDTYPE
GLOBAL pmesh_ptr AS DWORD
#CONSTANT MAX_OBJS 20
GLOBAL DIM objs(MAX_OBJS) AS PLANE_OBJECT

` default built in font		<--- BUILT IN FONT NOT WORKING!!! ARGH!!!
`GLOBAL dfont AS DWORD
`dfont = IGUI GET DEFAULT FONT()

` ------------------------------------------------------------------------------
` Initialise the DarkIrrlicht window

IRR INIT 1,800,600

` ------------------------------------------------------------------------------
` Initialise all the demo stuff

init_graphics( 128, 12 )
init_objects(1500,15,100)
init_camera()
init_cube()
update_timer()

REPEAT
	IVID BEGIN 1, 1, 0x00004080
	IDEV TIMER TICK
	
	run_camera()
	run_cube()
	update_timer()
	
	ISCN DRAW ALL
	`IFONT DRAW dfont, 0, 0, 0xffffffff, "FPS: " + STR$( IVID FPS() )
	IDEV SET WINDOW CAPTION "FPS: " + STR$( IVID FPS() )
	IVID END
UNTIL IRR KEYSTATE(32)

IRR DROP
END

` ------------------------------------------------------------------------------
` Delta timing

FUNCTION update_timer()
	LOCAL c#
	
	c# = IDEV GET TIME()
	dtel.tdel = ( c# - dtel.told ) / 33.0
	dtel.told = c#
ENDFUNCTION

` ------------------------------------------------------------------------------
`

FUNCTION init_graphics(size,gap)
	` local vars
	LOCAL c
	LOCAL p1
	LOCAL p2
	LOCAL col
	LOCAL raw
	LOCAL tname$
	
	` set the color array
	gfx(0).color = 0xffff0000
	gfx(1).color = 0xff00ff00
	gfx(2).color = 0xff0000ff
	
	FOR c=0 TO 2
		` create the image
		gfx(c).image = IIMG CREATE32( size, size )
		
		` lock the image for faster drawing (not using the raw pointer)
		raw = IIMG LOCK( gfx(c).image )
		
		` clear the image (usually has junk)
		IIMG FILL gfx(c).image, 0x00000000
		
		` draw the cross texture
		FOR p1=0 TO size
			FOR p2=0 TO gap
				col = RND(0x00ffffff) AND 0x007f7f7f
				col = col OR gfx(c).color
				IIMG SET PIXEL gfx(c).image, p1, p2, col, 0
				IIMG SET PIXEL gfx(c).image, p2, p1, col, 0
			NEXT p2
		NEXT p1
		
		` unlock now
		IIMG UNLOCK gfx(c).image
		
		` create the texture from the image
		tname$ = "tx"+str$(c)
		gfx(c).texture = IVID IMAGE TEXTURE( tname$, gfx(c).image )
		
	NEXT c
ENDFUNCTION

` ------------------------------------------------------------------------------
` Manually create the plane meshes to handle the lighting better

FUNCTION init_objects(size,scale,space)
	LOCAL buf AS DWORD
	LOCAL x AS INTEGER
	LOCAL y AS INTEGER
	LOCAL v AS INTEGER
	LOCAL xx#
	LOCAL yy#
	LOCAL v1 AS INTEGER
	LOCAL v2 AS INTEGER
	LOCAL v3 AS INTEGER
	LOCAL v4 AS INTEGER
	LOCAL i AS INTEGER
	LOCAL smat AS DWORD
	LOCAL c AS iNTEGER
	LOCAL dummy AS DWORD
	
	` grab a new SMesh and a new SMeshBuffer
	
	pmesh_ptr = ISMESH NEW()
	buf = ISMBUF NEW()
	iSMESH ADD MESH bufFER pmesh_ptr, buf
	
	` we can still use the buffer pointer even after dropping it
	
	iSMBUF DROP buf
	
	` setup the vertex and index sizes
	
	ISMBUF SET USED VERTICES buf, (scale+1) * (scale+1)
	ISMBUF SET USED INDICES buf, scale * scale * 6
	
	FOR x=0 TO scale
		FOR y=0 TO scale
			` vertex position in array
			
			v = ( y * ( scale + 1 ) ) + x
			
			` calc the position
			
			xx# = -( size / 2.0 ) + ( size / ( scale + 1.0 ) * x )
			yy# = -( size / 2.0 ) + ( size / ( scale + 1.0 ) * y )
			
			` set it up with normals, UV's, etc
			
			iSMBUF vERTEX POSITION buf, v, xx#, yy#, 0.0
			iSMBUF vERTEX NORMAL buf, v, 0.0, 0.0, -1.0
			iSMBUF vERTEX TCOORD buf, v, x, y
			ISMBUF VERTEX COLOR buf, v, 0xffffffff
			
			` setup the index table for the faces
			
			iF x<scale AND y<scale
				v1 = x + y * ( scale + 1 )
				v2 = v1 + scale + 1
				v3 = v2 + 1
				v4 = v1 + 1
				i  = ( x + y * scale ) * 6
				ISMBUF INDEX buf, i + 0, v1		` 1st face
				ISMBUF INDEX buf, i + 1, v2
				ISMBUF INDEX buf, i + 2, v3
				ISMBUF INDEX buf, i + 3, v3		` 2nd face
				ISMBUF INDEX buf, i + 4, v4
				ISMBUF INDEX buf, i + 5, v1
			ENDIF
		NEXT y
	NEXT x
	
	` recalc the bounding box (not really needed for this demo)
	
	ISMBUF CALC BOUNDING BOX buf
	
	` setup all the material parameters
	
	smat = ISMBUF GET MATERIAL( buf )
	IMAT SET AMBIENT smat, 0xffffffff
	IMAT SET DIFFUSE smat, 0xffffffff
	IMAT SET EMISSIVE smat, 0xffffffff
	IMAT SET SPECULAR smat, 0xffffffff
	IMAT SET SHININESS smat, 1.0			` <-- DOUBLE CHECK FUNCTION C++
	IMAT SET LIGHTING smat, 1
	IMAT SET MATERIAL TYPE smat, 13			` EMT_TRANSPARENT_ALPHA_CHANNEL
	
	` This bit isn't needed anymore, just looks uglier
	` although it still positions the mesh on the scene
	
	FOR c=0 TO MAX_OBJS
		objs(c).ang = 0.0
		objs(c).spd = c * 0.25 + 1.0
		objs(c).pos = c * space
		objs(c).node = ISCN ADD MESH NODE( 0, pmesh_ptr )
		INODE MATERIAL TEXTURE objs(c).node, 0, gfx(c MOD 3).texture
		INODE POS objs(c).node, 0, 0, c * space
	NEXT c
ENDFUNCTION

` ------------------------------------------------------------------------------
` Camera and Light handler

FUNCTION init_camera()
	cam.ang1 = 0.0
	cam.ang2 = 0.0
	cam.ang3 = 0.0
	cam.cam = ISCN ADD CAMERA NODE( 0 )
	cam.light = ISCN ADD LIGHT NODE( 0 )
	ILIGHT SET RADIUS cam.light, 250.0
ENDFUNCTION

FUNCTION run_camera()
	LOCAL x#
	LOCAL y#
	LOCAL z#
	LOCAL tx#
	LOCAL ty#
	LOCAL spd1#
	LOCAL spd2#
	LOCAL spd3#
	
	x# = COS( cam.ang1 ) * cam_rad1
	y# = SIN( cam.ang1 ) * cam_rad1
	z# = COS( cam.ang3 ) * cam_rad3 + cam_dst
	
	INODE POS cam.cam, x#, y#, z#
	
	tx# = COS( cam.ang2 ) * cam_rad2
	ty# = SIN( cam.ang2 ) * cam_rad2
	
	ICAM TARGET cam.cam, tx#, ty#, 20.0
	
	INODE POS cam.light, x#, y#, z#
	
	spd1# = cam_spd1 * dtel.tdel
	spd2# = cam_spd2 * dtel.tdel
	spd3# = cam_spd3 * dtel.tdel
	
	cam.ang1 = WRAPVALUE( cam.ang1 + spd1# )
	cam.ang2 = WRAPVALUE( cam.ang2 + spd2# )
	cam.ang3 = wrapvalue( cam.ang3 + spd3# )
ENDFUNCTION

` ------------------------------------------------------------------------------
` Cube node handler

FUNCTION init_cube()
	LOCAL smat AS DWORD
	cube_node = ISCN ADD CUBE NODE( 0, 40 )
	cube_ang = 0.0
	smat = INODE GET MATERIAL(cube_node,0)
	IMAT SET LIGHTING smat, 1
ENDFUNCTION

FUNCTION run_cube()
	INODE ROT cube_node, cube_ang, cube_ang, 0
	cube_ang = WRAPVALUE( cube_ang + 1.0 )
ENDFUNCTION

` ------------------------------------------------------------------------------
`

Some of the new features are:

New loaders for mdl, wal, smf
Cg support
Support for custom hardware cursors
Improved support for 64-bit platforms
Major OSX device improvements
Occlusion culling
Improved collada support
Improved shadows
Polygon offset support
ISceneLoader interface
Supporting now MSVC 2010 and 2012
New versions of support libraries
Video driver attribute query interface
Increased stability (lots of bugfixes!)