Any ideas?

EDIT:
Nevermind. I'm using Unity3D now.

Is there a way to use Tokamak or ODE with irrlicht.mod? If not, it would be awesome if you, gman, could make a wrapper for one.

Please Reply!

the method ScanCentralHeader of Type TZipFileList can be changed to the following code (or similar), in order to make extraction of CRX (Chrome Extension Files) possible via zipengine.

    

    Rem
        bbdoc: Scans the central header for files.  Returns true if successful.
    End Rem
    Method ScanCentralHeader:Int()
    
        SeekStream(zipFile, 0)
        Local magic_number:Int = ReadInt(zipFile);
        Local zip_start_pos:Int = 0;
        
        ' CRX FILE (Google Chrome Extension File), see: http://developer.chrome.com/extensions/crx.html
        If magic_number = $34327243 Then
            
            zip_start_pos:+4;
            
            ReadInt(zipFile); ' CRX Version
            zip_start_pos:+4;
            
            zip_start_pos:+ReadInt(zipFile); ' length of crx public key
            zip_start_pos:+4;
            
            zip_start_pos:+ReadInt(zipFile); ' length of crx signature
            zip_start_pos:+4;
            
            SeekStream(zipFile, zip_start_pos);
            magic_number:Int = ReadInt(zipFile);
            
        EndIf
        
        ' first check to see if its even a valid ZIP file
        If magic_number <> $04034b50 Then 
            DebugLog("Invalid ZIP file!")
            Return False
        EndIf
        
        Local header_start:Int = 0
        
        ' jump to the end
        SeekStream(zipFile, StreamSize(zipFile) - 4)
        
        ' seek the end central directory structure
        While Not StreamPos(zipFile) = 0
            Local sig:Int = ReadInt(zipFile)
            If sig = $06054b50 Then
                ' jump to start of central dir location    
                SeekStream(zipFile, StreamPos(zipFile) + 12)
                header_start = ReadInt(zipFile)
                Exit                
            Else
                ' rewind 3 bytes and try again
                SeekStream(zipFile, StreamPos(zipFile) - 5)
            EndIf
        EndWhile
    
        ' if we found the header, then process
        If Not header_start Then 
            DebugLog("unable to locate central directory!")
            Return False
        EndIf
        
        header_start:+zip_start_pos;
        
        ' seek to the start of the central directory
        SeekStream(zipFile, header_start)
        
        While True And Not Eof(zipFile)
            Local entry:SZipFileEntry = SZipFileEntry.Create()
            If entry.header.fill(zipFile) Then
                FileList.AddLast(entry)

                ' read filename
                entry.zipFileName = entry.header.FileName            
                extractFilename(entry)                                 
            Else
                Exit
            EndIf
        EndWhile
    
        Return True
    EndMethod

my problem is i want create a triangle like you can see in the following code. But i get an error every time in the surface.bmx. What should i do????

SuperStrict
Import irrlicht.b3d

ib3d_Graphics3D(800, 600, 32, 0, True, True, EDT_DIRECT3D8)



Global cam:CAMERA = ib3d_CreateCamera()
ib3d_PositionEntity(cam, 0, 0, -10)

Global light1:LIGHT = ib3d_CreateLight()
ib3d_PositionEntity(light1, 0, 0, 0)
 'SMeshBuffer() 

Global cube:MESH = ib3d_CreateMesh()
Global surf:SURFACE = ib3d_CreateSurface(cube, SF_NORMAL)    
Global v1:Int = ib3d_AddVertex(surf, 0,0 , 0)
Global v2:Int = ib3d_AddVertex(surf, 1, -1, 0)
Global v3:Int = ib3d_AddVertex(surf, -1, -1, 0)
ib3d_AddTriangle(surf, v1, v2, v3)
ib3d_UpdateNormals(cube)

While Not ib3d_KeyDown(KEY_ESCAPE)


    ib3d_UpdateWorld
    ib3d_RenderWorld
WEnd

Surface.bmx
The error show that something in this wrong in this Method:

    ' TODO: dont think this is working right.  need to examine source of addTestSceneNode().
    Method addVertex:Int(x:Float,y:Float,z:Float,nx:Float=0,ny:Float=0,nz:Float=0,u:Float=0,v:Float=0)
        If Not _mbuf Or Not _mbuf.isValid() Then RuntimeError "Surface meshbuffer is invalid"
Rem
        Local vert:S3DVertex=S3DVertexDefault.createFromVals(x,y,z,nx,ny,nz,SColor.createFromVals(255,255,255,255),u,v)
        Local vert_array:S3DVertex[1] = vert
        'DebugLog("before: "+_mbuf.getVertices().size())
        _mbuf.getVertices().push_back(vert)
        'DebugLog("after: "+_mbuf.getVertices().size())
EndRem
        RuntimeError "Not Implemented"
        Return _mbuf.getVertexCount()-1
    EndMethod

Irrlicht 1.8 is released!
Can you update your wrapper please?

Thank you very much in advance.

What's the best way to remove a certain file from multiple zip files (1000+) without having to recreate them manually each time?

A command like "zwObject.RemoveFile(filename)" would be quite helpful here.

Grisu

var distance : float = 3.0;
var height : float = 1.0;
var damping : float = 5.0;
var smoothRotation : boolean = true;
var rotationDamping : float = 10.0;
 
var targetLookAtOffset : Vector3;         // allows offsetting of camera lookAt, very useful for low bumper heights
 
var bumperDistanceCheck : float = 2.5;    // length of bumper ray
var bumperCameraHeight : float = 1.0;     // adjust camera height while bumping
var bumperRayOffset : Vector3;             // allows offset of the bumper ray from target origin
 
// If the target moves, the camera should child the target to allow for smoother movement. DR
function Awake()
{
    camera.transform.parent = target;
}
 
function FixedUpdate() {
 
    var wantedPosition = target.TransformPoint(0, height, -distance);
 
    // check to see if there is anything behind the target
    var hit : RaycastHit;
    var back = target.transform.TransformDirection(-1 * Vector3.forward);    
 
    // cast the bumper ray out from rear and check to see if there is anything behind
    if (Physics.Raycast(target.TransformPoint(bumperRayOffset), back, hit, bumperDistanceCheck) 
              && hit.transform != target) { // ignore ray-casts that hit the user. DR
        // clamp wanted position to hit position
        wantedPosition.x = hit.point.x;
        wantedPosition.z = hit.point.z;
        wantedPosition.y = Mathf.Lerp(hit.point.y + bumperCameraHeight, wantedPosition.y, Time.deltaTime * damping);
    } 
 
    transform.position = Vector3.Lerp(transform.position, wantedPosition, Time.deltaTime * damping);
 
    var lookPosition : Vector3 = target.TransformPoint(targetLookAtOffset);
 
    if (smoothRotation) {
        var wantedRotation : Quaternion = Quaternion.LookRotation(lookPosition - transform.position, target.up);
        transform.rotation = Quaternion.Slerp(transform.rotation, wantedRotation, Time.deltaTime * rotationDamping);
    } else {
        transform.rotation = Quaternion.LookRotation(lookPosition - transform.position, target.up);
    }
}

enum direction {forward, reverse, stop};
 
public var parentToGround : boolean = false;                // automatically updates the parent to the object below to allow for moving objects to affect object
public var groundRayOffset : Vector3 = Vector3.zero;        // adjust where the parentToGround ray is cast from
public var groundRayCastLength : float = 1.0;                // how far does the parentToGround ray cast
 
public var topSpeedForward : float = 3.0;                     // top speed of forward
public var topSpeedReverse : float = 1.0;                     // top speed of reverse
public var accelerationRate : float = 3;                     // rate at which top speed is reached
public var decelerationRate : float = 2;                     // rate at which speed is lost when not accelerating
public var brakingDecelerationRate : float = 4;                // rate at which speed is lost when braking (input opposite of current direction)
public var stoppedTurnRate : float = 2.0;                    // rate at which object turns when stopped
public var topSpeedForwardTurnRate : float = 1.0;            // rate at which object turns at top forward speed
public var topSpeedReverseTurnRate : float = 2.0;            // rate at which object turns at top reverse speed
public var gravity = 10.0;                                    // gravity for object
public var stickyThrottle : boolean = false;                 // true to disable loss of speed if no input is provided
public var stickyThrottleDelay : float = .35;                // delay between change of direction when sticky throttle is enabled
 
private var currentSpeed : float = 0.0;                     // stores current speed
private var currentTopSpeed : float = topSpeedForward;         // stores top speed of current direction
private var currentDirection : direction = direction.stop;     // stores current direction
private var isBraking : boolean = false;                     // true if input is braking
private var isAccelerating : boolean = false;                 // true if input is accelerating
private var stickyDelayCount : float = 9999.0;                // current sticky delay count
private var characterController : CharacterController;
 
function Start() {
    characterController = GetComponent(CharacterController);
}
 
function FixedUpdate() {
 
    // direction to move this update
    var moveDirection : Vector3 = Vector3.zero;
    // direction requested this update
    var requestedDirection : direction = direction.stop;
 
    if(characterController.isGrounded == true) {
        // simulate loss of turn rate at speed
        var currentTurnRate = Mathf.Lerp((currentDirection == direction.forward ? topSpeedForwardTurnRate : topSpeedReverseTurnRate), stoppedTurnRate, (1- (currentSpeed/currentTopSpeed)));        
        transform.eulerAngles.y += Input.GetAxis("Horizontal") * currentTurnRate;
 
        // based on input, determine requested action
        if (Input.GetAxis("Vertical") > 0) { // requesting forward
            requestedDirection = direction.forward;
            isAccelerating = true;
        } else if (Input.GetAxis("Vertical") < 0) { // requesting reverse
            requestedDirection = direction.reverse;
            isAccelerating = true;
        } else {
            requestedDirection = currentDirection;
            isAccelerating = false;
        }
 
        isBraking = false;
 
        if (currentDirection == direction.stop) { // engage new direction
            stickyDelayCount += Time.deltaTime;
            // if we are not sticky throttle or if we have hit the delay then change direction
            if (!stickyThrottle || stickyDelayCount > stickyThrottleDelay) {
                // make sure we can go in the requsted direction
                if (requestedDirection == direction.reverse && topSpeedReverse > 0 || 
                    requestedDirection == direction.forward && topSpeedForward > 0) {
 
                    currentDirection = requestedDirection;
                }
            }
        } else if (currentDirection != requestedDirection) { // requesting a change of direction, but not stopped so we are braking
            isBraking = true;
            isAccelerating = false;
        }
 
        // setup top speeds and move direction
        if (currentDirection == direction.forward) {
            moveDirection = Vector3.forward;
            currentTopSpeed = topSpeedForward;
        } else if (currentDirection == direction.reverse) {
            moveDirection = (-1 * Vector3.forward);
            currentTopSpeed = topSpeedReverse;
        } else if (currentDirection == direction.stop) {
            moveDirection = Vector3.zero;
        }
 
        if (isAccelerating) {
            //if we havent hit top speed yet, accelerate
           if (currentSpeed < currentTopSpeed){ 
                currentSpeed += (accelerationRate * Time.deltaTime);     
           }
        } else {
            // if we are not accelerating and still have some speed, decelerate
            if (currentSpeed > 0) {
                // adjust deceleration for braking and implement sticky throttle
                var currentDecelerationRate : float = (isBraking ? brakingDecelerationRate : (!stickyThrottle ? decelerationRate : 0));
                currentSpeed -= (currentDecelerationRate * Time.deltaTime);  
            }
        }
 
        // if our speed is below zero, stop and initialize
        if (currentSpeed < 0 || (currentSpeed == 0 && currentDirection != direction.stop)) {
            SetStopped();
        } else if (currentSpeed > currentTopSpeed) { // limit the speed to the current top speed
            currentSpeed = currentTopSpeed;
        }
 
        moveDirection = transform.TransformDirection(moveDirection);
    }
 
    // implement gravity so we can stay grounded
    moveDirection.y -= gravity * Time.deltaTime;
    moveDirection.z = moveDirection.z * (Time.deltaTime * currentSpeed);
    moveDirection.x = moveDirection.x * (Time.deltaTime * currentSpeed);
    characterController.Move(moveDirection);
 
    if (parentToGround) {
        var hit : RaycastHit;
        var down = transform.TransformDirection (-1 * Vector3.up);    
 
        // cast the bumper ray out from bottom and check to see if there is anything below
        if (Physics.Raycast (transform.TransformPoint(groundRayOffset), down, hit, groundRayCastLength)) {
            // clamp wanted position to hit position
            transform.parent = hit.transform;
        }
 
        // if we are currently stopped, move just a tad to allow for collisions while parent is moving
        if (currentDirection == direction.stop) {
            characterController.SimpleMove(transform.TransformDirection(Vector3.forward) * 0.000000000001);        
        }
    }
 
}
 
function GetCurrentSpeed() {
    return currentSpeed;
}
 
function GetCurrentTopSpeed() {
    return currentTopSpeed;
}
 
function GetCurrentDirection() {
    return currentDirection;
}
 
function GetIsBraking() {
    return isBraking;
}
 
function GetIsAccelerating() {
    return isAccelerating;
}
 
function SetStopped() {
    currentSpeed = 0;
    currentDirection = direction.stop;
    isAccelerating = false;
    isBraking = false;
    stickyDelayCount = 0;
}
 
@script RequireComponent(CharacterController)