Up to date support for bmax :)

[Game Producer]

LE2 had tons of features, way more than I needed. I bet LE3 too. I really am not so much into new features, or newer fancy graphics (it's so nice already )

 

What I do want is that Bmax headers (or whatever they are called) stay updated

[Canardia]

I'm quite sure the BlitzMax headers will be officially supported, because the number of BlitzMax users is almost as high as C++ users.

[afecelis]

I'm a bit concerned on this topic as well as it seems C++ , C# and Lua will be the only programming options for LE3.

As a non-programmer user, bmax seems a lot more understandable and easier to pick up than C++, so keeping it among the supported languages would be a major plus.

The other option I'm considering is Lua as it's also more newbie-friendly, my only worry here is performance when comparing an interpreted to a compiled language like C++.

 

But I'm glad you guys brought it up. I also know Josh is quite busy with LE3 and solving out major stuff for it so let's hope he still has some time to consider the use of Bmax

 

cheers,

 

Alvaro

[Josh]

A BlitzMax import file or module will be provided.

 

There will be no documentation or official tutorials for BlitzMax. It's only being supported at this point because I am using it to write the editor. The language is no longer being developed, unfortunately , so it's not something I want to promote.

 

Blitz is a really good illustration why free upgrades for life is a bad idea.

[Marleys Ghost]

A BlitzMax import file or module will be provided.

 

There will be no documentation or official tutorials for BlitzMax. It's only being supported at this point because I am using it to write the editor. The language is no longer being developed, unfortunately , so it's not something I want to promote.

 

Blitz is a really good illustration why free upgrades for life is a bad idea.

 

 

 

M'kay ... not really a big incentive for this Bmaxer to upgrade.

[Rick]

I think BMax in LE3 should become community driven much like C#, Java, Delphi, etc, but that's because I don't use it and wouldn't want Josh to spend any resources supporting it. Some BMax users will no doubt leave, but I think a good number will stay and either learn C++ or Lua. I don't know about other people but the API itself is the reason I like using LE not the language it's in.

[Marleys Ghost]

I think BMax in LE3 should become community driven much like C#, Java, Delphi, etc, but that's because I don't use it and wouldn't want Josh to spend any resources supporting it. Some BMax users will no doubt leave, but I think a good number will stay and either learn C++ or Lua. I don't know about other people but the API itself is the reason I like using LE not the language it's in.

 

 

 

TBH, and please dont take this the wrong way, but your personal preferences in this regard are of no value to me, and if the option is to learn a new language then it won't be c++ or lua

[macklebee]

M'kay ... not really a big incentive for this Bmaxer to upgrade.

 

agree...

[Josh]

There's no need for the community to implement this because I have the include file I am using for the editor. It just calls the C API, so there's no need for separate docs in BMX syntax. The C API is what the DLL exposes, so you just look at the docs and it matches the BMX commands.

 

I am interested in getting a Leadwerks Engine 3 subforum in the BMX modules forum category, and I'll write Mark and ask when the time is closer.

 

SuperStrict

Import brl.pngloader
Import "le3.lib"
Import "le_const.bmx"
Import "le_types.bmx"

Extern "c"

'General
'Function leSetHook(hookid:Int,hook:Byte Ptr)="SetHook"
Function leGetLogText_(char:Byte Ptr,length:Int)="GetLogText"

'Bank
Function lePeekBankByte:Int(bank:LEBank,position:Int)="PeekBankByte"
Function leGetBankSize:Int(bank:LEBank)="GetBankSize"
Function leGetBankBuffer:Byte Ptr(bank:LEBank)="GetBankBuffer"

'Network
Function leCreateServer:leServer(port:Int)="CreateServer"
Function leUpdateServer:leMessage(server:leServer,timeout:Int)="UpdateServer"
Function leDisconnectServer(server:leServer,client:LEPeer,force:Int)="DisconnectServer"
Function leSendServer:Int(server:leServer,client:LEPeer,messageid:Int,date:Byte Ptr,size:Int,channel:Int,flags:Int)="SendServer"

'Window
Function leCreateWindow:leWindow(title$z,width:Int,height:Int,style:Int)="CreateWindow"
Function leCreateCustomWindow:leWindow(hwnd:Int)="CreateCustomWindow"
Function leGetWindowWidth:Int(window:leWindow)="GetWindowWidth"
Function leGetWindowHeight:Int(window:leWindow)="GetWindowHeight"
Function leSetWindowShape(window:LEWindow,x:Int,y:Int,width:Int,height:Int)="SetWindowShape"
Function leFreeWindow(window:leWindow)="FreeWindow"

'Graphics driver
Function leSetGraphicsDriver(graphicsdriver:LEGraphicsDriver)="SetGraphicsDriver"
Function leCreateOpenGL1GraphicsDriver:LEOpenGL1GraphicsDriver()="CreateOpenGL1GraphicsDriver"
Function leCreateOpenGL3GraphicsDriver:LEOpenGL3GraphicsDriver()="CreateOpenGL3GraphicsDriver"
Function leGetGraphicsDriver:LEGraphicsDriver()="GetGraphicsDriver"
Function leGetGraphicsDriverName_:Int(graphicsdriver:LEGraphicsDriver,name:Byte Ptr,length:Int)="GetGraphicsDriverName"
Function leGetGraphicsDriverVendor:Int(graphicsdriver:LEGraphicsDriver)="GetGraphicsDriverVendor"
Function leGraphicsDriverSupported:Int(graphicsdriver:LEGraphicsDriver)="GraphicsDriverSupported"
Function leBuffersSupported:Int()="BuffersSupported"

'File system
Function leSetDir(path$z)="SetDir"

'Context
Function leCreateContext:LEContext(window:LEWindow,multisamplemode:Int)="CreateContext"
Function leSwapContext(context:LEContext,sync:Int)="SwapContext"
'Function leFreeContext(context:LEContext)="FreeContext"

'Buffer
Function leCreateBuffer:LEBuffer(width:Int,height:Int,colortextures:Int,depthtexture:Int,multisamplemode:Int)="CreateBuffer"	
Function leClearBuffer(Buffer:LEBuffer,Mode:Int)="ClearBuffer"
Function leGetBufferColorTexture:LETexture(Buffer:LEBuffer,index:Int)="GetBufferColorTexture"
Function leGetBufferDepthTexture:LETexture(Buffer:LEBuffer)="GetBufferDepthTexture"
Function leGetBuffer:LEBuffer()="GetBuffer"
Function leGetBufferWidth:Int(buffer:LEBuffer)="GetBufferWidth"
Function leGetBufferHeight:Int(buffer:LEBuffer)="GetBufferHeight"
Function leSetBuffer(Buffer:LEBuffer)="SetBuffer"
Function leFreeBuffer(Buffer:LEBuffer)="FreeBuffer"
Function leGetBufferPixels(buffer:LEBuffer,buf:Byte Ptr,component:Int)="GetBufferPixels"

'World
Function leCreateWorld:LEWorld()="CreateWorld"
Function leSetWorld(World:LEWorld)="SetWorld"
Function leGetWorld:LEWorld()="GetWorld"
Function leRenderWorld()="RenderWorld"
Function leFreeWorld(World:LEWorld)="FreeWorld"
Function leSetWorldAmbientLight(world:LEWorld,r:Float,g:Float,b:Float,a:Float)="SetWorldAmbientLight"

'Entity
Function leSetEntityPosition(entity:LEEntity,x:Float,y:Float,z:Float,glb:Int)="SetEntityPosition"
Function leSetEntityRotation(entity:LEEntity,x:Float,y:Float,z:Float,glb:Int)="SetEntityRotation"
Function leGetEntityPosition(entity:LEEntity,rotation:Byte Ptr,glb:Int)="GetEntityPosition"
Function leGetEntityRotation(entity:LEEntity,rotation:Byte Ptr,glb:Int)="GetEntityRotation"
Function leGetEntityMatrix(entity:LEEntity,matrix:Byte Ptr)="GetEntityMatrix"
Function leMoveEntity(entity:LEEntity,x:Float,y:Float,z:Float,glb:Int)="MoveEntity"
Function leTurnEntity(entity:LEEntity,x:Float,y:Float,z:Float,glb:Int)="TurnEntity"
Function leAlignEntityToVector(entity:LEEntity,x:Float,y:Float,z:Float,axis:Int,rate:Float,roll:Float)="AlignEntityToVector"
Function leSetEntityMaterial(entity:LEEntity,material:LEMaterial)="SetEntityMaterial"
Function leFreeEntity(entity:LEEntity)="FreeEntity"
Function leHideEntity(entity:LEEntity)="HideEntity"
Function leShowEntity(entity:LEEntity)="ShowEntity"
Function leGetEntityAABB(entity:LEEntity,aabb:Byte Ptr,Mode:Int)="GetEntityAABB"
Function leCountEntityChildren(entity:LEEntity)="CountEntityChildren"
Function leGetEntityChild(entity:LEEntity,n:Int)="GetEntityChild"
Function leSetEntityParent(entity:LEEntity,parent:LEEntity,glb:Int)="SetEntityParent"
Function leEntityHidden:Int(entity:LEEntity)="EntityHidden"

'Pivot
Function leCreatePivot:LEPivot(parent:LEEntity)="CreatePivot"

'Camera
Function leCreateCamera_:LECamera(parent:LEEntity)="CreateCamera"
Function leSetCameraProjectionMode(Camera:LECamera,projectionmode:Int)="SetCameraProjectionMode"
Function leGetCameraProjectionMode:Int(Camera:LECamera)="GetCameraProjectionMode"
Function leSetCameraClearColor(Camera:LECamera,r:Float,g:Float,b:Float,a:Float)="SetCameraClearColor"
Function leGetCameraClearColor(Camera:LECamera,color:TVec4)="GetCameraClearColor"
Function leSetCameraZoom(Camera:LECamera,zoom:Float)="SetCameraZoom"
Function leGetCameraZoom:Float(Camera:LECamera)="GetCameraZoom"
Function leSetCameraDrawMode(Camera:LECamera,Mode:Int)="SetCameraDrawMode"
Function leSetCameraRange(camera:LECamera,nearrange:Float,farrange:Float)="SetCameraRange"
Function leGetCameraRange(camera:LECamera,Range:Byte Ptr)="GetCameraRange"
Function leSetCameraFOV(camera:LECamera,fov:Float)="SetCameraFOV"
Function leGetCameraFOV:Float(camera:LECamera)="GetCameraFOV"
Function leSetCameraMotionBlurMode(camera:LECamera,mode:Int)="SetCameraMotionBlurMode"
Function leSetCameraViewport(camera:LECamera,x:Float,y:Float,width:Float,height:Float)="SetCameraViewport"
Function leGetCameraViewport(camera:LECamera,viewport:Byte Ptr)="GetCameraViewport"

'Light
Function leCreateDirectionalLight:LEDirectionalLight(parent:LEEntity)="CreateDirectionalLight"

'Model
Function leLoadModel:LEModel(path$z,flags:Int)="LoadModel"
Function leCreateModelSphere:LEModel(sides:Int)="CreateModelSphere"
Function leCreateCube:LEModel(parent:LEEntity)="CreateCube"
Function leFlipModelNormals(model:LEModel)="FlipModelNormals"
'Function leCreateModelSphere:Byte Ptr(sides:Int)="CreateModelSphere"

'Timing
Function leUPS:Float()="UPS"
Function leUpdateTime()="UpdateTime"

'Font
Function leLoadfont:LEFont(path$z,size:Int,style:Int,family:Int)="LoadFont"
Function leDrawFontText(font:LEFont,text$z,x:Int,y:Int,kerning:Float)="DrawFontText"
Function leGetFontTextWidth(font:LEFont,text$z)="GetFontTextWidth"
Function leGetFontHeight(font:LEFont)="GetFontHeight"
Function leFreeFont(font:LEFont)="FreeFont"

'Drawing
Function leDrawLine(x0:Int,y0:Int,x1:Int,y1:Int)="DrawLine"
Function leDrawRect(x:Int,y:Int,width:Int,height:Int,style:Int)="DrawRect"
Function leDrawImage(image:LETexture,x:Int,y:Int,width:Int,height:Int)="DrawImage"
Function leSetBlendMode(blendmode:Int)="SetBlendMode"
Function leSetColor(r:Float,g:Float,b:Float,a:Float)="SetColor"
Function leSetClearColor(r:Float,g:Float,b:Float,a:Float)="SetClearColor"
Function leSetScale(x:Float,y:Float)="SetScale"
Function leSetRotation(rotation:Float)="SetRotation"
Function leSetTranslation(x:Float,y:Float)="SetTranslation"
Function leTileImage(texture:LETexture)="TileImage"
Function leSetViewport(x:Int,y:Int,width:Int,height:Int)="SetViewport"

'Asset
Function leGetAssetName_:Int(asset:LEAsset,name:Byte Ptr,length:Int)="GetAssetName"
Function leGetAssetAssetReference:LEAssetReference(asset:LEAsset)="GetAssetAssetReference"
Function leReloadAsset:Int(asset:LEAsset,flags:Int)="ReloadAsset"

'Asset Reference
Function leFindAssetReference:LEAssetReference(name$z)="FindAssetReference"
Function leReloadAssetReference:Int(assetreference:LEAssetReference,flags:Int)="ReloadAssetReference"
Function leSetAssetReferenceName(assetreference:LEAssetReference,name$z)="SetAssetReferenceName"

'Texture
Function leCreatetexture:LETexture(width:Int,height:Int,format:Int,flags:Int,frames:Int)="CreateTexture"
Function leLoadTexture_:LETexture(path$z,flags:Int)="LoadTexture"
Function leGetTextureTarget:Int(texture:LETexture)="GetTextureTarget"
'Function leLockTexture(texture:LETexture,miplevel:Int,framenumber:Int)="LockTexture"
'Function leUnlockTexture(texture:LETexture,miplevel:Int,framenumber:Int)="UnlockTexture"
'Function leWriteTexturePixel(texture:LETexture,x:Int,y:Int,r:Int,g:Int,b:Int,a:Int,miplevel:Int,framenumber:Int)="WriteTexturePixel"
'Function leReadTexturePixel:Int(texture:LETexture,x:Int,y:Int,miplevel:Int,framenumber:Int)="ReadTexturePixel"
Function leGetTexturePixels(texture:LETexture,buf:Byte Ptr,miplevel:Int,framenumber:Int,face:Int)="GetTexturePixels"
Function leSetTexturePixels(texture:LETexture,buf:Byte Ptr,miplevel:Int,framenumber:Int,face:Int)="SetTexturePixels"	
Function leGetTextureWidth(texture:LETexture,miplevel:Int)="GetTextureWidth"
Function leGetTextureHeight(texture:LETexture,miplevel:Int)="GetTextureHeight"
Function leSetTextureFilter(texture:LETexture,texturefilter:Int)="SetTextureFilter"
Function leFreeTexture(texture:LETexture)="FreeTexture"
'Function leTextureLocked(texture:LETexture,miplevel:Int,framenumber:Int)="TextureLocked"
'Function leReloadTexture:Int(texture:LETexture,flags:Int)="ReloadTexture"
Function leBindTexture(texture:LETexture,index:Int)="BindTexture"
Function leGetTextureData:Byte Ptr(texture:LETexture,miplevel:Int,framenumber:Int)="GetTextureData"
Function leCountTextureMipmaps:Int(texture:LETexture)="CountTextureMipmaps"
Function leGetTextureMipmapSize:Int(texture:LETexture)="GetTextureMipmapSize"
Function leGetTextureFormat:Int(texture:LETexture)="GetTextureFormat"
Function leSetTextureClampMode(texture:LETexture,x:Int,y:Int,z:Int)="SetTextureClampMode"
Function leGetTextureClampMode:Int(texture:LETexture,axis:Int)="GetTextureClampMode"
Function leGetTextureAnisotropy:Float(texture:LETexture)="GetTextureAnisotropy"
Function leSetTextureAnisotropy(texture:LETexture,anisotropy:Float)="SetTextureAnisotropy"

'Shader
Function leLoadshader:LEShader(path$z,flags:Int)="LoadShader"
Function leSetShader(shader:LEShader)="SetShader"
'Function leReloadShader:Int(shader:LEShader,flags:Int)="ReloadShader"
Function leSetShaderFloat:Int(shader:LEShader,name$z,f:Float)="SetShaderFloat"
Function leSetShaderVec2:Int(shader:LEShader,name$z,x:Float,y:Float)="SetShaderVec2"
Function leSetShaderVec4:Int(shader:LEShader,name$z,x:Float,y:Float,z:Float,w:Float)="SetShaderVec4"
Function leSetShaderMat4:Int(shader:LEShader,name$z,mat:Byte Ptr)="SetShaderMat4"
Function leFreeShader(shader:LEShader)="FreeShader"
Function leSetShaderSource(shader:LEShader,source$z,n:Int)="SetShaderSource"
Function leGetShaderSource_:Int(shader:LEShader,n:Int,s:Byte Ptr,l:Int)="GetShaderSource"
Function leGetShaderError_:Int(shader:LEShader,s:Byte Ptr,l:Int)="GetShaderError"
Function leCompileShader:Int(shader:LEShader,n:Int)="CompileShader"
Function leLinkShader:Int(shader:LEShader)="LinkShader"
Function leCreateShader:LEShader()="CreateShader"

'Material
Function leLoadmaterial:LEMaterial(path$z,flags:Int)="LoadMaterial"
Function leChooseMaterialShader:LEShader(material:LEMaterial)="ChooseMaterialShader"
Function leGetMaterialTexture:LETexture(material:LEMaterial,index:Int)="GetMaterialTexture"
Function leSetMaterialShader(material:LEMaterial,shader:LEShader)="SetMaterialShader"
Function leGetMaterialShader:LEShader(material:LEMaterial)="GetMaterialShader"
Function leSetMaterialTexture(material:LEMaterial,texture:LETexture,index:Int)="SetMaterialTexture"
Function leFreeMaterial(material:LEMaterial)="FreeMaterial"
Function leSetMaterialBlendMode(material:LEMaterial,mode:Int)="SetMaterialBlendMode"
Function leGetMaterialBlendMode:Int(material:LEMaterial)="GetMaterialBlendMode"
Function leSetMaterialShadowMode(material:LEMaterial,mode:Int)="SetMaterialShadowMode"
Function leGetMaterialShadowMode:Int(material:LEMaterial)="GetMaterialShadowMode"
Function leSetMaterialBackFaceCullMode(material:LEMaterial,mode:Int)="SetMaterialBackFaceCullMode"
Function leGetMaterialBackFaceCullMode:Int(material:LEMaterial)="GetMaterialBackFaceCullMode"
Function leSetMaterialZSortMode(material:LEMaterial,mode:Int)="SetMaterialZSortMode"
Function leGetMaterialZSortMode:Int(material:LEMaterial)="GetMaterialZSortMode"
Function leSetMaterialDepthTestMode(material:LEMaterial,mode:Int)="SetMaterialDepthTestMode"
Function leGetMaterialDepthTestMode:Int(material:LEMaterial)="GetMaterialDepthTestMode"
Function leSetMaterialFloat(material:LEMaterial,name$z,x:Float)="SetMaterialFloat"
Function leSetMaterialVec2(material:LEMaterial,name$z,x:Float,y:Float)="SetMaterialVec2"
Function leSetMaterialVec3(material:LEMaterial,name$z,x:Float,y:Float,z:Float)="SetMaterialVec3"
Function leSetMaterialVec4(material:LEMaterial,name$z,x:Float,y:Float,z:Float,w:Float)="SetMaterialVec4"
Function leGetMaterialFloat:Float(material:LEMaterial,name$z)="GetMaterialFloat"
Function leGetMaterialVec4(material:LEMaterial,name$z,v:Byte Ptr)="GetMaterialVec4"
Function leMaterialContainsValue:Int(material:LEMaterial,name$z)="MaterialContainsValue"

EndExtern

Private

Global char:Byte[102400]

Public

Function leGetShaderSource:String(shader:LEShader,n:Int)
Local char:Byte[]
char=char[..leGetShaderSource_(shader,n,Null,0)+1]
leGetShaderSource_(shader,n,char,char.length)
Return String.FromCString(char)
EndFunction

Function leGetShaderError:String(shader:LEShader)
Local char:Byte[]
char=char[..leGetShaderError_(shader,Null,0)+1]
leGetShaderError_(shader,char,char.length)
Return String.FromCString(char)
EndFunction

Function leGetAssetName:String(asset:LEAsset)
Local char:Byte[]
char=char[..leGetAssetName_(asset,Null,0)+1]
leGetAssetName_(asset,char,char.length)
Return String.FromCString(char)
EndFunction

Function leGetGraphicsDriverName:String(graphicsdriver:LEGraphicsDriver)
Local char:Byte[]
char=char[..leGetGraphicsDriverName_(graphicsdriver,Null,0)+1]
leGetGraphicsDriverName_(graphicsdriver,char,char.length)
Return String.FromCString(char)
EndFunction

Function leGetLogText:String()
Local char:Byte[]
char=char[..leGetLogText_(Null,0)+1]
leGetLogText_(char,char.length)
Return String.FromCString(char)
EndFunction

Function leLoadtexture:LETexture(path:String,flags:Int=0)
Local ext:String
Local pixmap:TPixmap

ext=ExtractExt(path).tolower()
Select ext
Case "tex","thb" Return leLoadTexture_(path,flags)
Default
	pixmap=LoadPixmap(path)
	If pixmap
		Return lePixmapToTexture(pixmap)
	EndIf
EndSelect
EndFunction

Function leSaveTexture:Int(texture:LETexture,path:String)
Local pixmap:TPixmap=leTextureToPixmap(texture)

If pixmap
	Select ExtractExt(path).tolower()
	Case "png" Return SavePixmapPNG(pixmap,path)
	'Case "bmp" Return SavePixmapBMP(pixmap,path)
	'Case "tga" Return SavePixmapTGA(pixmap,path)
	Default Return False
	EndSelect
EndIf
Return False
EndFunction

Function leTextureToPixmap:TPixmap(texture:LETexture)
Local pixmap:TPixmap=CreatePixmap(leGetTextureWidth(texture,0),leGetTextureHeight(texture,0),PF_RGBA8888)
Local x:Int,y:Int,color:Int
'Local lockmode:Int=leTextureLocked(texture,0,0)
'If Not lockmode leLockTexture(texture,0,0)
'For x=0 To pixmap.width-1
'	For y=0 To pixmap.height-1
'		pixmap.WritePixel(x,y,leReadTexturePixel(texture,x,y,0,0))
'	Next
'Next
'If Not lockmode leUnlockTexture(texture,0,0)
leGetTexturePixels texture,pixmap.pixels,0,0,0
Return pixmap
EndFunction

Function leCreateCamera:LECamera(parent:LEEntity)
'DebugStop
Return leCreateCamera_(parent)
EndFunction

Function lePixmapToTexture:LETexture(pixmap:TPixmap)
Local texture:LETexture
Local x:Int,y:Int,color:Byte[4],colori:Int
If pixmap.format<>PF_RGBA8888 pixmap=pixmap.convert(PF_RGBA8888)
texture = leCreateTexture(pixmap.width,pixmap.height,LE_TEXTURE_RGBA,0,1)
If texture
	'leLockTexture(texture,0,0)
	'For x=0 To pixmap.width-1
	'	For y=0 To pixmap.height-1
	'		colori = pixmap.ReadPixel(x,y)
	'		MemCopy color,Varptr colori,4
	'		leWriteTexturePixel(texture,x,y,color[2],color[1],color[0],color[3],0,0)
	'	Next
	'Next
	'leUnlockTexture(texture,0,0)
	leSetTexturePixels(texture,pixmap.pixels,0,0,0)
	'Print "BMX: "+Int(pixmap.pixels)
EndIf
Return texture
EndFunction

[Rick]

TBH, and please dont take this the wrong way, but your personal preferences in this regard are of no value to me

 

I didn't think it would be and I'm not taking it the wrong way, but you aren't the only person on this thread and it wasn't directly related to your response (I actually had that written about 30 mins or so I think before your post but something came up). I apologize if I made it come off as if it was. It was a thought to invoke for Josh, but seems he's got it all planned out. It is interesting that it'll be indirectly related because of the editor though.

 

Weren't the BMax people getting an OO library today? If this would be going through the C DLL I assume that changes?

[macklebee]

There's no need for the community to implement this because I have the include file I am using for the editor. It just calls the C API, so there's no need for separate docs in BMX syntax. The C API is what the DLL exposes, so you just look at the docs and it matches the BMX commands.

 

I am interested in getting a Leadwerks Engine 3 subforum in the BMX modules forum category, and I'll write Mark and ask when the time is closer.

 

??

 

why not just a bmax category in the LE3 programming forums? seems that would make more sense...

[Marleys Ghost]

Actually my concern was emphasised "It's only being supported at this point because I am using it to write the editor. "

which gives the impression that at sometime in the future there will not be an include file or module in a later update.

 

 

I am interested in getting a Leadwerks Engine 3 subforum in the BMX modules forum category, and I'll write Mark and ask when the time is closer.

 

 

In addition to a Werkspace forum for LE3 and Bmax? or instead of?

[cassius]

I am a programmer of limited ability but I won't have a problem translating c++ api functiond into bmav.

As long as there are third party examples such as we have now I will be ok.

I also know the basics of c++ and c#

[Game Producer]

bmax doesn't need special tutorials, C++ tutorials are just perfect, since they illustrate the use of bmax and can be easily understood (bmax isn't too different anyway, so it's not a biggie).

 

bmax is currently stable enuf and doesn't really need more updates for it to be useful for me.

 

but when LE gets updated, having up-to-date LE header/module/whatnot is more than welcome, so the Josh's current plan is great.

 

"why subforum in bmax forums"

=> makes sense, since that also promotes the product and will get more bmax folks interested if LE would be part of the official bmax forums. I feel that it might be useful to also have bmax subforum in LE... or "general" programming forum, since folks here have more experience on LE (no matter what language they use)

[cassius]

A lot of people use bmax on this forum and while many of us could switch to c+= without too much hassle we prefer not to do so.

Bmax is good enough as it stands without further development at least for a few years.

[Josh]

If you're comfortable using BlitzMax, I don't see any reason to change. If I was making a PC game my personal preference would be to definitely use that with LE3, over C# or C++. It's more cross-platform compatible with less mess.

 

Of course, LE3's implementation of Lua has the best cross-platform support, based on the fact it works without having to install any separate compilers or IDEs, and it runs the same on everything. With the LE3 Lua debugger I hope it will be useful for more complex programming. I like it because I have complete control and can provide a programming environment with no reliance on third party software or compilers.

[cassius]

Will lua be any faster in le3?

[Josh]

It is possible it may be if the binding library is faster. I wouldn't be surprised if this is the case, but it's hard to perform an objective test.

[Paul Thomas]

Wow, this whole thread seems like a slap in the face to anyone who uses BlitzMax, which is probably 30% (if not more) of your customer base. I'd also be as bold to say that most of the projects presented here that are even worth mentioning are written with BMax by BMax users. Are you saying BMax users will have to use a forum over at BlitzBasic for LE related topics? How does that make any sense at all, beyond trying to hide the fact that LE uses BlitzMax in any shape or form? Either what was written was mistyped or I'm misreading what is written.

 

Also, one of the main objectives seems to be selling source licenses, correct? From the start the licensee's are going to see how everything was written in C++ but the editor was written in a language that isn't even listed on the website, and apparently, has no forum category either. Wouldn't that be a bit odd?

 

As a side note, I thought it was a "plus" to advertise an engine that supports so many languages, and it's understood that you could only "officially" support so many, but since you're using BMax for the editor, that tells me it's officially supported. Whether it's admitted openly or not, the editor keeps up with the engine, and therefore the "BMax include file" would be consistently kept up-to-date. Unless you eventually have plans to rewrite the editor in another language, like C++ or C#? If so, wouldn't that also mean that support for BlitzMax is no longer "officially" supported?

[cassius]

An ADITTIONAL forum on blitz website would be fine, but keep the one here also.

[Rick]

Also, one of the main objectives seems to be selling source licenses, correct? From the start the licensee's are going to see how everything was written in C++ but the editor was written in a language that isn't even listed on the website, and apparently, has no forum category either. Wouldn't that be a bit odd?

 

I don't think that's odd at all. GUI applications are often written in RAD languages but games are often not. I do think Josh is still at an odd spot because he clearly likes BMax and is very used to it and that's why he wrote the editor with it, but if it's a dead language then he will eventually need to move on from it, but he doesn't want to. I'm sure he's not happy about BMax dying but languages come and go with a few that just have staying power. If Josh would be thinking long term he wouldn't write the editor in BMax but he doesn't want to spend the time learning another language for the editor.

 

 

I'd also be as bold to say that most of the projects presented here that are even worth mentioning are written with BMax by BMax users.

 

I think the whole dead language is a pretty big issue. BMax will simply fizzle out in a few years without updates/fixes so it would seem logical to slowly stop supporting it, which is kind of what it seems Josh is doing. Hey, I really enjoyed VB 6 but it's dead. Sometimes as a programmer you have to move on to another language and keep current.

[Canardia]

The new Editor is actually not so much in BlitzMax as the old one. It uses the C++ engine dll, and does only the UI stuff in BlitzMax. It's quite easy then to replace the UI stuff with a real C++ UI in future.

[TheoLogic]

The new Editor is actually not so much in BlitzMax as the old one. It uses the C++ engine dll, and does only the UI stuff in BlitzMax. It's quite easy then to replace the UI stuff with a real C++ UI in future.

 

I don't think C++ is a good choice for UI development. .NET or Java are way better UI languages... Maintaining a C++ based UI is just a time spender!

[Canardia]

Many companies and products are recently switching to Qt4, which is a very nice UI system for C++, and you don't need to maintain it yourself, because Nokia is maintaining it.

[Rick]

Honestly given a great editor like VS C++ would be just as easy as .NET or Java. There is no reason a huge majority of the functionality these other libraries give can't be used in C++ but it's all about the editor creating the code behind the scenes. Without an editor to do that for us even languages like .NET would be a pain to code in since you'd have to code all that form stuff manually.