void MDLMeshImporter::CreateShader( NWN::TrimeshGeometryNode* pTrimesh, Mesh* pMesh, Bool pMetallic )
{
TextureShader* shader = NULL;
if( ToLower(pTrimesh->mBitmap) != "null" )
{
String textureName = "Data/Textures/";
if( pTrimesh->mBitmap.find( '.' ) != -1 )
{
textureName += pTrimesh->mBitmap;
}
else
{
textureName += pTrimesh->mBitmap;
textureName += String(".tga");
}
HTexture2D hdl( textureName );
if( hdl && (hdl->GetFormat() == Image::Format_R8G8B8A8 || hdl->GetFormat() == Image::Format_B8G8R8A8) )
{
if( pMetallic )
{
//shader = GD_NEW(MetallicShader, this, "MetallicShader");
//((MetallicShader*)shader)->mReflectionTexture.GetTexture( "Data/Textures/chrome1.tga" );
shader = GD_NEW(TextureShader, this, "TextureShader");
}
else
{
shader = GD_NEW(TransparencyTextureShader, this, "TransparencyTextureShader");
}
}
else
{
shader = GD_NEW(TextureShader, this, "TextureShader");
}
shader->mTexture = hdl;
}
if( !shader )
shader = GD_NEW(TextureShader, this, "TextureShader");
shader->mMaterial.mAmbient = pTrimesh->mAmbient;
shader->mMaterial.mDiffuse = pTrimesh->mDiffuse;
shader->mMaterial.mSpecular = pTrimesh->mSpecular;
shader->mMaterial.mShininess = pTrimesh->mShininess;
shader->mMaterial.mEmissive = pTrimesh->mEmissive;
pMesh->mShader = shader;
}
void kDOPTree::BuildTree( Vector<Trianglef>& pTriangleSoup, Vector<Vector3f>& pVertices )
{
// Keep a copy of the vertices and triangles.
mVertices.resize( pVertices.size() );
for( UInt32 i = 0; i < pVertices.size(); i++ )
mVertices[i] = pVertices[i];
mTriangles.resize( pTriangleSoup.size() );
for( UInt32 i = 0; i < pTriangleSoup.size(); i++ )
{
mTriangles[i].mIndices[0] = pTriangleSoup[i].mIndices[0];
mTriangles[i].mIndices[1] = pTriangleSoup[i].mIndices[1];
mTriangles[i].mIndices[2] = pTriangleSoup[i].mIndices[2];
}
mTrianglesCentroids.resize( pTriangleSoup.size() );
// Find each triangle center.
for( UInt32 i = 0; i < pTriangleSoup.size(); i++ )
{
mTrianglesCentroids[i] = mVertices[mTriangles[i].mIndices[0]];
mTrianglesCentroids[i] += mVertices[mTriangles[i].mIndices[1]];
mTrianglesCentroids[i] += mVertices[mTriangles[i].mIndices[2]];
mTrianglesCentroids[i] *= (1.0f / 3.0f);
}
mNumNodes = 1;
mNumLeaves = 0;
mMaxDepth = 0;
mDepth = 0;
// Create the root node.
kDOPNode* root = GD_NEW(kDOPNode, this, "Engine::Collision::kDOPTree");
mNodes.push_back( root );
// Insert the triangles indices in the root node list.
root->mTriangleIndices.resize( pTriangleSoup.size() );
for( UInt32 i = 0; i < pTriangleSoup.size(); i++ )
{
root->mTriangleIndices[i] = i;
}
// Recursively build kDOP tree.
BuildNode( root );
// No need to store centroids.
mTrianglesCentroids.clear();
/*
#ifdef GD_DEBUG
//
// Report memory usage
UInt32 memUsage = 0;
memUsage += (mNodes.size() * 4) + (mNodes.size() * sizeof(kDOPNode));
memUsage += mVertices.size() * sizeof(mVertices[0]);
memUsage += mTriangles.size() * sizeof(mTriangles[0]);
printf( "kDOPTree mem usage = %08d bytes", memUsage );
#endif
*/
}
void EditorBase::LoadTools()
{
ModuleManager::Instance()->LoadModulesInFolder( "Plugins/Tools/" );
// Create the tools and init their UI;
Class::Iterator itClassesNew( EditorTool::StaticClass() );
for( ; itClassesNew.IsValid(); ++itClassesNew )
{
EditorTool* newTool = Cast<EditorTool>((*itClassesNew)->AllocateNew());
try
{
newTool->SetEditor(this);
QWidget* toolWidget = newTool->CreateUI();
if( toolWidget != mMainView )
{
QDockWidget* contentsWindow = GD_NEW(QDockWidget, this, 0)(toolWidget->objectName(), this);
contentsWindow->setWidget(toolWidget);
addDockWidget(Qt::LeftDockWidgetArea, contentsWindow);
}
newTool->Hide();
mTools[(*itClassesNew)->GetName()] = newTool;
}
catch( Exception& e )
{
qWarning( e.GetMessage().c_str() );
GD_DELETE(newTool);
}
}
}
void LWOReader::ReadPOLS( UInt32 pChunkSize )
{
UInt32 dataRead = 0;
UInt16 numVertex;
UInt32 polygonType;
LWPolygon* newPolygon;
dataRead += ReadID4( polygonType );
while( dataRead < pChunkSize )
{
newPolygon = GD_NEW(LWPolygon, this, "Polygon");
dataRead += ReadU2( numVertex );
newPolygon->mFlags = (0xFC00 & numVertex) >> 10;
numVertex = 0x03FF & numVertex;
newPolygon->mType = polygonType;
newPolygon->mVertex = GD_NEW_ARRAY(LWPolygonVertex, numVertex, this, "Polygon::Vertex");
newPolygon->mVertexCount = numVertex;
// Read indices and assign them to each vertex
for( UInt32 iIndex = 0; iIndex < newPolygon->mVertexCount; iIndex++ )
dataRead += ReadVX( newPolygon->mVertex[iIndex].mIndex );
GetCurrentLayer()->mPolygonList.mPolygons.push_back( newPolygon );
}
}
void Init()
{
Super::Init();
mWorld = GD_NEW(World, this, "Launch::Gamedesk");
mWorld->Init(&mOctree);
Model3D* pModel = Cast<Model3D>(mWorld->SpawnEntity(Model3D::StaticClass()));
pModel->SetMesh("link's house.ase");
pModel->Select(true);
Keyboard& keyboard = InputSubsystem::GetKeyboard();
keyboard.AddKeyListener(this, Keyboard::Key_W, Keyboard::Key_Down);
keyboard.AddKeyListener(this, Keyboard::Key_S, Keyboard::Key_Down);
keyboard.AddKeyListener(this, Keyboard::Key_A, Keyboard::Key_Down);
keyboard.AddKeyListener(this, Keyboard::Key_D, Keyboard::Key_Down);
keyboard.AddKeyListener(this, Keyboard::Key_Escape, Keyboard::Key_Down);
Mouse& mouse = InputSubsystem::GetMouse();
mouse.AddMoveListener(this);
mMainWindow->AddListener(this);
mFont.GetFont( "Data/Fonts/tahoma.ttf", 14 );
}
LWLayer* LWOReader::GetCurrentLayer()
{
if( mObject->mLayers.size() == 0 )
mObject->mLayers.push_back( GD_NEW(LWLayer, this, "Layer") );
return mObject->mLayers.back();
}
void BSPReader::Read( const String& pFileName )
{
mMemoryFile = GD_NEW(MemoryFile, this, "BSPImporter::BSPReader::MemoryFile")( pFileName, true );
mBSPFile.mData = GD_NEW_ARRAY(Byte, mMemoryFile->GetSize(), this, "BSPImporter::BSPReader::BSP Data");
memcpy( mBSPFile.mData, mMemoryFile->GetMemory(), mMemoryFile->GetSize() );
mBSPFile.mHeader = (BSPHeader*)mBSPFile.mData;
}
void kDOPTree::BuildNode( kDOPTree::kDOPNode* pNode )
{
mDepth++;
if( mDepth > mMaxDepth )
mMaxDepth = mDepth;
FindBoundingBox( pNode );
// Test if we're creating a leaf or a node.
if( pNode->mTriangleIndices.size() > 5 )
{
mNumNodes++;
Float axisMean;
Axis splitAxis = SelectSplitAxis( pNode->mTriangleIndices, axisMean );
// Add two nodes.
kDOPNode* leftNode = GD_NEW(kDOPNode, this, "Engine::Collision::kDOPTree");
kDOPNode* rightNode = GD_NEW(kDOPNode, this, "Engine::Collision::kDOPTree");
pNode->mChildsIndex = mNodes.size();
mNodes.push_back( leftNode );
mNodes.push_back( rightNode );
// Split triangles into two list.
SplitTriangles( pNode, splitAxis, axisMean );
// No need to store this in nodes.
pNode->mTriangleIndices.clear();
// Recursively call build tree.
BuildNode( leftNode );
BuildNode( rightNode );
}
else
{
// No work to do for leaves!
mNumLeaves++;
}
mDepth--;
}
Mesh* MDLMeshImporter::CreateMesh( NWN::GeometryNode* pNode, Mesh* pParent, Bool pMetallic )
{
Mesh* mesh = NULL;
switch( pNode->GetType() )
{
// Trimesh (& danglymesh) have geometry, so create it.
case NWN::DANGLY_MESH_ID:
case NWN::TRIMESH_ID:
mesh = GD_NEW(Mesh, this, "Mesh");
if( ((NWN::TrimeshGeometryNode*)pNode)->mRender && !((NWN::TrimeshGeometryNode*)pNode)->mTransparencyHint )
{
CreateGeometry( (NWN::TrimeshGeometryNode*)pNode, mesh );
CreateShader( (NWN::TrimeshGeometryNode*)pNode, mesh, pMetallic );
}
break;
case NWN::EMITTER_ID:
case NWN::DUMMY_ID:
case NWN::AABB_ID:
mesh = GD_NEW(Mesh, this, "Mesh");
break;
default:
return NULL;
}
// Create all childs recursivly.
for( std::map<String,NWN::Node*>::iterator itMap = pNode->mChilds.begin(); itMap != pNode->mChilds.end(); ++itMap )
CreateMesh( (NWN::GeometryNode*)(itMap->second), mesh, pMetallic );
// Add the new mesh to it's parent (and store his relative position and orientation).
if( pParent )
{
mesh->SetName(pNode->mName);
//mesh->SetPosition(((NWN::DummyGeometryNode*)pNode)->mPosition);
//mesh->SetOrientation(Quaternionf( ((NWN::DummyGeometryNode*)pNode)->mRotationVector, ((NWN::DummyGeometryNode*)pNode)->mRotationAngle));
pParent->AddChild(mesh);
}
return mesh;
}
// ------------------------------------------------------------------------------------------
//! Creates a 2D text renderer with specified parameters.
//! @param gfxSamplerStatePtr Pointer for output.
//! @param gfxSamplerStateCreationInfo Pointer to the sampler state creation information.
//! @returns Non-negative value if the operation succeeded.
GDAPI IResult IGraphics2DDirect2DWithFonts::GfxImm_FontCreate(IGraphics2DFont** gfxFontPtr
, IGraphics2DFontCreationInfo const* const gfxFontCreationInfo)
{
#if GD_DEBUG
if (!GD_IGRAPHICS_CHECK_ARGS(GfxImm_FontCreate(gfxFontPtr, gfxFontCreationInfo)))
return IResult::InvalidArguments;
#endif // if GD_DEBUG
*gfxFontPtr = GD_NEW(IGraphics2DDirect2DFont, gfxFontCreationInfo);
return IResult::Ok;
}
void LWOReader::ReadLAYR( UInt32 pChunkSize )
{
UInt32 dataRead = 0;
LWLayer* newLayer = GD_NEW(LWLayer, this, "Layer");
dataRead += ReadU2( newLayer->mNumber );
dataRead += ReadU2( newLayer->mFlags );
dataRead += ReadVEC12( newLayer->mPivot );
dataRead += ReadS0( newLayer->mName );
if( dataRead < pChunkSize )
dataRead += ReadU2( newLayer->mParent );
mObject->mLayers.push_back( newLayer );
}
Variant& ConfigSection::Get( const String& pVarName, Variant pDefaultValue )
{
Variant* variant = NULL;
Map<String,Variant*>::iterator itMap = mVars.find( pVarName );
// If we've found the section in our map, return it immediately.
if( itMap != mVars.end() )
{
variant = (*itMap).second;
}
// Otherwise we need to create it.
else
{
variant = GD_NEW(Variant, this, "Core::Config::ConfigSection::Variant")( pDefaultValue );
mVars[pVarName] = variant;
}
return *variant;
}
ConfigSection& ConfigFile::operator [] ( const String& pSectionName )
{
ConfigSection* section = NULL;
Map<String,ConfigSection*>::iterator itMap = mSections.find( pSectionName );
// If we've found the section in our map, return it immediately.
if( itMap != mSections.end() )
{
section = (*itMap).second;
}
// Otherwise we need to create it.
else
{
section = GD_NEW(ConfigSection, this, "Core::Config::ConfigFile::ConfigSection")( pSectionName, *this );
mSections[pSectionName] = section;
}
return *section;
}
QRenderWindow::QRenderWindow( QWidget* parent, RenderListener* pRenderListener ) :
QWidget( parent, 0 ),
mRefreshRate(0),
mRenderWindow(NULL),
mRenderListener(pRenderListener),
mFPS(0),
mTime(0),
mLastTime(0),
mFrameCount(0)
{
if( !mRenderWindowClass )
{
ConfigFile editorConfig( "editor.cfg" );
editorConfig.Load();
String renderWndClassName = editorConfig["RenderWindow"]["ClassName"];
if( renderWndClassName.empty() )
throw ConfigFileMissingValueException( "editor.cfg", "RenderWindow", "ClassName", Here );
mRenderWindowClass = ModuleManager::Instance()->LoadClass( renderWndClassName.c_str() );
}
RenderWindow::WindowInfo windowInfo;
windowInfo.mWindowInternal = (Handle)this;
windowInfo.mWindowHandle = (Handle)winId();
windowInfo.mSize.x = width();
windowInfo.mSize.y = height();
windowInfo.mFullscreen = false;
RenderTarget::Format targetFormat;
targetFormat.mAlpha = true;
targetFormat.mDepth = true;
targetFormat.mDoubleBuffer = true;
targetFormat.mStencil = true;
targetFormat.mStereo = false;
mRenderWindow = Cast<RenderWindow>( mRenderWindowClass->AllocateNew() );
mRenderWindow->Create( windowInfo, targetFormat );
mAVIEncoder = GD_NEW(AVIEncoder, this, "EditorLib::Viewer::QRenderWindow")( this );
}
EditorBase::EditorBase( QWidget* parent, const char* name, Qt::WFlags f ) :
QMainWindow( parent, f ),
mMainView(0),
mWorldManager(0),
mTime(0),
mLastTime(0)
{
mInstance = this;
setObjectName(name);
setWindowTitle("Gamedesk Editor");
statusBar()->showMessage(tr("Ready"));
InitActions();
InitMenu();
QBrush bgBrush( QColor( 0, 0, 0 ) );
mWorldManager = GD_NEW(WorldManager, this, "EditorLib::EditorBase");
LoadTools();
}
void SetupWindows()
{
mMainWindow = GD_NEW(Win32Window, this, "Launch::Gamedesk");
mMainWindow->Init( "Gamedesk", 800, 600, true, false );
RenderWindow::WindowInfo windowInfo;
windowInfo.mWindowInternal = (Handle)mMainWindow;
windowInfo.mWindowHandle = (Handle)mMainWindow->GetHandle();
windowInfo.mFullscreen = mMainWindow->IsFullScreen();
windowInfo.mSize = mMainWindow->GetClientSize();
RenderTarget::Format targetFormat;
targetFormat.mAlpha = true;
targetFormat.mDepth = true;
targetFormat.mDoubleBuffer = true;
targetFormat.mStencil = true;
targetFormat.mStereo = false;
Class* renderWindowClass = ModuleManager::Instance()->LoadClass( "Win32OGLRenderWindow.Win32OGLRenderWindow" );
mRenderWindow = Cast<RenderWindow>( renderWindowClass->AllocateNew() );
mRenderWindow->Create( windowInfo, targetFormat );
mLastTime = SystemInfo::Instance()->GetSeconds();
}
void LWOReader::ReadCLIP( UInt32 pChunkSize )
{
UInt32 dataRead = 0;
UInt32 subChunkTag;
UInt16 subChunkSize;
UInt32 bytesHold;
LWClip* newClip = GD_NEW(LWClip, this, "Clip");
dataRead += ReadU4( newClip->mIndex );
// Read all subchunks
while( dataRead < pChunkSize )
{
if( (pChunkSize - dataRead) < 6 )
{
dataRead += Skip( pChunkSize - dataRead );
return;
}
subChunkTag = ReadSubChunk(subChunkSize);
dataRead += sizeof(subChunkTag); // Subchunk tag.
dataRead += sizeof(subChunkSize); // Subchunk size.
bytesHold = dataRead;
switch( subChunkTag )
{
case ID_STIL:
dataRead += ReadS0( newClip->mStillImage );
break;
case ID_XREF:
dataRead += ReadVX( newClip->mXRefIndex );
dataRead += ReadS0( newClip->mXRefInstName );
break;
case ID_ISEQ:
case ID_ANIM:
case ID_STCC:
case ID_TIME:
case ID_CONT:
case ID_BRIT:
case ID_SATR:
case ID_HUE:
case ID_GAMM:
case ID_NEGA:
case ID_IFLT:
case ID_PFLT:
default:
dataRead += Skip( subChunkSize );
break;
}
// Make sure we've read all subchunk bytes (given by the size).
if( (subChunkSize - dataRead + bytesHold) > 0 )
dataRead += Skip( subChunkSize - dataRead + bytesHold );
}
mObject->mClips.push_back( newClip );
}
Resource* ASEImporter::Import( const String& pFilename, const String& /*pParams*/ )
{
ASEFile aseFile;
try
{
ASE::MeshReader reader(aseFile);
reader.Read( pFilename );
}
catch( Exception& /*e*/ )
{
return NULL;
}
if(aseFile.mGeomObjects.size() == 0)
return NULL;
Map<const ASEFile::Material*, ASESubMesh> mSubMeshes;
GenerateSubMeshes(aseFile, mSubMeshes);
// Create mesh instance
Mesh* newMesh = Cast<Mesh>(GraphicSubsystem::Instance()->Create( Mesh::StaticClass() ));
// Create all submeshes
Map<const ASEFile::Material*, ASESubMesh>::const_iterator itSubMesh;
Map<const ASEFile::Material*, ASESubMesh>::const_iterator itSubMeshBegin = mSubMeshes.begin();
Map<const ASEFile::Material*, ASESubMesh>::const_iterator itSubMeshEnd = mSubMeshes.end();
for(itSubMesh = itSubMeshBegin; itSubMesh != itSubMeshEnd; ++itSubMesh)
{
const ASEFile::Material& mat = *(*itSubMesh).first;
const ASESubMesh& aseSubMesh = (*itSubMesh).second;
// Create the sub mesh
Mesh* subMesh = Cast<Mesh>(GraphicSubsystem::Instance()->Create( Mesh::StaticClass() ));
newMesh->AddChild(subMesh);
// Create VB
subMesh->GetVertexList().Allocate( aseSubMesh.mVertices.size(), (VertexFormat::Component) (VertexFormat::Position3 | VertexFormat::Normal3 | VertexFormat::TexCoord2 ));
Vector3f* ptrPosition = subMesh->GetVertexList().GetPositions();
Vector3f* ptrNormal = subMesh->GetVertexList().GetNormals();
Vector2f* ptrTexCoord = subMesh->GetVertexList().GetTextureCoords();
UInt32 i = 0;
for(Vector<ASEVertex>::const_iterator itVertex = aseSubMesh.mVertices.begin(); itVertex != aseSubMesh.mVertices.end(); ++itVertex, ++i)
{
ptrPosition[i].x = (*itVertex).mPosition.x;
ptrPosition[i].y = (*itVertex).mPosition.z;
ptrPosition[i].z = (*itVertex).mPosition.y;
ptrNormal[i].x = (*itVertex).mNormal.x;
ptrNormal[i].y = (*itVertex).mNormal.z;
ptrNormal[i].z = (*itVertex).mNormal.y;
ptrTexCoord[i] = (*itVertex).mUV;
}
// Create IB
{
subMesh->GetTriangles().Allocate( TriangleBatch::TriangleList, aseSubMesh.mIndices.size());
UInt16* ptrIndices = subMesh->GetTriangles().GetIndices();
UInt32 i = 0;
for(Vector<UInt32>::const_iterator itIndex = aseSubMesh.mIndices.begin(); itIndex != aseSubMesh.mIndices.end(); ++itIndex, ++i)
ptrIndices[i] = *itIndex;
}
// Shader
{
TextureShader* shader = GD_NEW(TextureShader, this, "TextureShader");
if(mat.mMapDiffuse.mBitmap.size() != 0)
{
HTexture2D hdl( mat.mMapDiffuse.mBitmap );
hdl->GetImage().FlipY();
hdl->Update();
shader->mTexture = hdl;
}
else if(mat.mMapGeneric.mBitmap.size() != 0)
{
HTexture2D hdl( mat.mMapGeneric.mBitmap );
hdl->GetImage().FlipY();
hdl->Update();
shader->mTexture = hdl;
}
shader->mMaterial.mAmbient = Color4f(mat.mAmbient.R, mat.mAmbient.G, mat.mAmbient.B);
shader->mMaterial.mDiffuse = Color4f(mat.mDiffuse.R, mat.mDiffuse.G, mat.mDiffuse.B);
//shader->mMaterial.mSpecular = Color4f(mat.mSpecular.R, mat.mSpecular.G, mat.mSpecular.B);
shader->mMaterial.mShininess = mat.mShine;
subMesh->mShader = shader;
}
}
return newMesh;
}
void LWOReader::ReadVMAP( UInt32 pChunkSize, Bool pPerPoly )
{
UInt32 dataRead = 0;
UInt16 dimension;
LWIndex vertexIndex;
LWIndex polygonIndex;
LWVertexMap* newVertexMap = GD_NEW(LWVertexMap, this, "VertexMap");
newVertexMap->mPerPoly = pPerPoly;
dataRead += ReadID4( newVertexMap->mType );
dataRead += ReadU2( dimension );
dataRead += ReadS0( newVertexMap->mName );
while( dataRead < pChunkSize )
{
dataRead += ReadVX( vertexIndex );
newVertexMap->mVertexIndex.push_back( vertexIndex );
if( pPerPoly )
{
dataRead += ReadVX( polygonIndex );
newVertexMap->mPolygonIndex.push_back( polygonIndex );
}
LWMapValue mapping;
switch( newVertexMap->mType )
{
case ID_PICK:
mapping.mPick = vertexIndex;
break;
case ID_WGHT:
dataRead += ReadF4( mapping.mWeight );
break;
case ID_TXUV:
dataRead += ReadF4( mapping.mUV.U );
dataRead += ReadF4( mapping.mUV.V );
break;
case ID_RGB:
dataRead += ReadF4( mapping.mRGB.R );
dataRead += ReadF4( mapping.mRGB.G );
dataRead += ReadF4( mapping.mRGB.B );
break;
case ID_RGBA:
dataRead += ReadF4( mapping.mRGBA.R );
dataRead += ReadF4( mapping.mRGBA.G );
dataRead += ReadF4( mapping.mRGBA.B );
dataRead += ReadF4( mapping.mRGBA.A );
break;
case ID_MORF:
case ID_SPOT:
case ID_MNVW:
default:
dataRead += Skip( dimension * sizeof(Float) );
break;
}
newVertexMap->mValues.push_back( mapping );
}
GetCurrentLayer()->mVertexMaps.push_back( newVertexMap );
}
void LWOReader::ReadSURF( UInt32 pChunkSize )
{
UInt32 dataRead = 0;
UInt16 subChunkSize;
UInt32 subChunkTag;
UInt32 bytesHold;
LWIndex env;
LWSurface* newSurface = GD_NEW(LWSurface, this, "Surface");
dataRead += ReadS0( newSurface->mSurfaceName );
dataRead += ReadS0( newSurface->mSurfaceFile );
// Read all subchunks
while( dataRead < pChunkSize )
{
if( (pChunkSize - dataRead) < 6 )
{
dataRead += Skip( pChunkSize - dataRead );
return;
}
subChunkTag = ReadSubChunk(subChunkSize);
dataRead += sizeof(subChunkTag); // Subchunk tag.
dataRead += sizeof(subChunkSize); // Subchunk size.
bytesHold = dataRead;
switch( subChunkTag )
{
case ID_COLR:
dataRead += ReadCOL12( newSurface->mBaseColor );
dataRead += ReadVX( env );
break;
case ID_DIFF:
dataRead += ReadFP4( newSurface->mDiffuse );
dataRead += ReadVX( env );
break;
case ID_LUMI:
dataRead += ReadFP4( newSurface->mLuminosity );
dataRead += ReadVX( env );
break;
case ID_SPEC:
dataRead += ReadFP4( newSurface->mSpecular );
dataRead += ReadVX( env );
break;
case ID_REFL:
dataRead += ReadFP4( newSurface->mReflection );
dataRead += ReadVX( env );
break;
case ID_TRAN:
dataRead += ReadFP4( newSurface->mTransparency );
dataRead += ReadVX( env );
break;
case ID_TRNL:
dataRead += ReadFP4( newSurface->mTranslucency );
dataRead += ReadVX( env );
break;
case ID_GLOS:
dataRead += ReadFP4( newSurface->mSpecularGlossiness );
dataRead += ReadVX( env );
break;
case ID_SHRP:
dataRead += ReadFP4( newSurface->mDiffuseSharpness );
dataRead += ReadVX( env );
break;
case ID_BUMP:
dataRead += ReadFP4( newSurface->mBumpStrength );
dataRead += ReadVX( env );
break;
case ID_SIDE:
dataRead += ReadU2( newSurface->mPolySide );
break;
case ID_SMAN:
dataRead += ReadANG4( newSurface->mMaxSmoothingAngle );
break;
case ID_RFOP:
dataRead += ReadU2( newSurface->mReflectionOptions );
break;
case ID_RIMG:
dataRead += ReadVX( newSurface->mReflectionMapImage );
break;
case ID_RSAN:
dataRead += ReadANG4( newSurface->mReflMapSeamAngle );
dataRead += ReadVX( env );
break;
case ID_RBLR:
dataRead += ReadFP4( newSurface->mReflBlurPercent );
dataRead += ReadVX( env );
break;
case ID_CLRH:
dataRead += ReadFP4( newSurface->mColorHighlights );
dataRead += ReadVX( env );
break;
case ID_TROP:
dataRead += ReadU2( newSurface->mTransparencyOptions );
dataRead += Skip( subChunkSize - sizeof(UInt16) );
break;
case ID_CLRF:
dataRead += ReadFP4( newSurface->mColorFilter );
dataRead += ReadVX( env );
break;
case ID_ADTR:
dataRead += ReadFP4( newSurface->mAdditiveTransparency );
dataRead += ReadVX( env );
break;
case ID_ALPH:
dataRead += ReadU2( newSurface->mAlphaMode );
dataRead += ReadFP4( newSurface->mAlphaValue );
break;
case ID_BLOK:
ReadBLOK( newSurface, subChunkSize );
dataRead += subChunkSize;
break;
case ID_VCOL:
case ID_LINE:
case ID_GLOW:
case ID_TBLR:
case ID_TIMG:
case ID_RIND:
default: dataRead += Skip( subChunkSize ); break;
}
// Make sure we've read all subchunk bytes (given by the size).
if( (subChunkSize - dataRead + bytesHold) > 0 )
dataRead += Skip( subChunkSize - dataRead + bytesHold );
}
mObject->mSurfaces.push_back( newSurface );
}
void LWOReader::ReadBLOK( LWSurface* pSurface, UInt32 pChunkSize )
{
UInt32 dataRead = 0;
UInt16 subChunkSize;
UInt32 subChunkTag;
UInt32 bytesHold;
LWSurfaceBlock* newSurfaceBlock = GD_NEW(LWSurfaceBlock, this, "SurfaceBlock");
//dataRead += ReadS0( newSurfaceBlock->mOrdinalString );
// Read all subchunks
while( dataRead < pChunkSize )
{
subChunkTag = ReadSubChunk(subChunkSize,1);
dataRead += sizeof(subChunkTag); // Subchunk tag.
dataRead += sizeof(subChunkSize); // Subchunk size.
bytesHold = dataRead;
switch( subChunkTag )
{
case ID_IMAP:
case ID_PROC:
case ID_GRAD:
case ID_SHDR:
newSurfaceBlock->mType = subChunkTag;
ReadHEAD( newSurfaceBlock, subChunkSize );
dataRead += subChunkSize;
break;
case ID_TMAP:
ReadTMAP( &newSurfaceBlock->mTextureMapping, subChunkSize );
dataRead += subChunkSize;
break;
case ID_PROJ:
dataRead += ReadU2( newSurfaceBlock->mImageMap.mProjectionMode );
break;
case ID_AXIS:
dataRead += ReadU2( newSurfaceBlock->mImageMap.mProjectionAxis );
break;
case ID_IMAG:
newSurfaceBlock->mImageMap.mValid = true;
dataRead += ReadVX( newSurfaceBlock->mImageMap.mImageMap );
break;
case ID_WRAP:
dataRead += ReadU2( newSurfaceBlock->mImageMap.mWrapModeWidth );
dataRead += ReadU2( newSurfaceBlock->mImageMap.mWrapModeHeight );
break;
case ID_VMAP:
dataRead += ReadS0( newSurfaceBlock->mImageMap.mUVVertexMapName );
break;
default:
dataRead += Skip( subChunkSize );
break;
}
// Make sure we've read all subchunk bytes (given by the size).
if( (subChunkSize - dataRead + bytesHold) > 0 )
dataRead += Skip( subChunkSize - dataRead + bytesHold );
}
pSurface->mBlocks.push_back( newSurfaceBlock );
}
Resource* WoWImporter::Import( const String& pFilename, const String& /*pParams*/ )
{
WoW::ADTFile adtFile;
WoW::ADTFileReader adtFileReader( adtFile );
adtFileReader.Read( pFilename );
WorldTile* worldTile = GD_NEW(WorldTile, this, "WoW::WorldTile");
worldTile->GetTerrainChunks().resize( 256 );
worldTile->GetVertexList().Allocate( 16*16 * (9*9 + 8*8), (VertexFormat::Component) (VertexFormat::Position3 | VertexFormat::TexCoord2 | VertexFormat::TexCoord2_2 | VertexFormat::Normal3) );
Vector3f* ptrPosition = worldTile->GetVertexList().GetPositions();
Vector3f* ptrNormal = worldTile->GetVertexList().GetNormals();
Vector2f* ptrTexCoord = worldTile->GetVertexList().GetTextureCoords();
Vector2f* ptrTexCoordAlpha = worldTile->GetVertexList().GetTextureCoords_2();
UInt32 verticesOffset = 0;
Vector3f firstChunkPos(0,0,0);//-1.0f*adtFile.mMapChunks[0].mHeader.mPosition.y, adtFile.mMapChunks[0].mHeader.mPosition.z, -1.0f*adtFile.mMapChunks[0].mHeader.mPosition.x );
for( UInt32 iChunk = 0; iChunk < 256; iChunk++ )
{
WoW::ADTFile::MapChunk* mapChunk = &adtFile.mMapChunks[iChunk];
// Append vertex data to vertex buffer
Float* ptrDataHeight = mapChunk->mHeightMap;
Char* ptrDataNormals = mapChunk->mHeightMapNormals[0];
Vector3f chunkPos( -1.0f*mapChunk->mHeader.mPosition.y, mapChunk->mHeader.mPosition.z, -1.0f*mapChunk->mHeader.mPosition.x );
Float posX = chunkPos.x - firstChunkPos.x;
Float posZ = chunkPos.z - firstChunkPos.z;
for( UInt32 z = 0; z < 9; z++ )
{
// Normal row
posX = chunkPos.x - firstChunkPos.x;
for( UInt32 x = 0; x < 9; x++ )
{
ptrPosition->x = posX;
ptrPosition->y = chunkPos.y + (*ptrDataHeight) - firstChunkPos.y;
ptrPosition->z = posZ;
(*ptrPosition) *= 0.1f;
ptrNormal->x = ((Float)ptrDataNormals[0]) / 127.0f;
ptrNormal->y = ((Float)ptrDataNormals[1]) / 127.0f;
ptrNormal->z = ((Float)ptrDataNormals[2]) / 127.0f;
ptrTexCoord->x = x / 8.0f;
ptrTexCoord->y = z / 8.0f;
ptrTexCoordAlpha->x = (x+0.125f) / 8.25f;
ptrTexCoordAlpha->y = (z+0.125f) / 8.25f;
ptrDataHeight++;
ptrDataNormals += 3;
ptrPosition++;
ptrNormal++;
ptrTexCoord++;
ptrTexCoordAlpha++;
posX += UNIT_SIZE;
}
posZ += 0.5f * UNIT_SIZE;
if( z == 8 )
break;
// Detailed row
posX = chunkPos.x + 0.5f * UNIT_SIZE - firstChunkPos.x;
for( UInt32 x = 0; x < 8; x++ )
{
ptrPosition->x = posX;
ptrPosition->y = chunkPos.y + (*ptrDataHeight) - firstChunkPos.y;
ptrPosition->z = posZ;
(*ptrPosition) *= 0.1f;
ptrNormal->x = ((Float)ptrDataNormals[0]) / 127.0f;
ptrNormal->y = ((Float)ptrDataNormals[1]) / 127.0f;
ptrNormal->z = ((Float)ptrDataNormals[2]) / 127.0f;
ptrTexCoord->x = (x+0.5f) / 8.0f;
ptrTexCoord->y = (z+0.5f) / 8.0f;
ptrTexCoordAlpha->x = (x+0.5f+0.125f) / 8.25f;
ptrTexCoordAlpha->y = (z+0.5f+0.125f) / 8.25f;
ptrDataHeight++;
ptrDataNormals += 3;
ptrPosition++;
ptrNormal++;
ptrTexCoord++;
ptrTexCoordAlpha++;
posX += UNIT_SIZE;
}
posZ += 0.5f * UNIT_SIZE;
}
WorldTile::TerrainChunk* newChunk = GD_NEW(WorldTile::TerrainChunk, this, "WoW::WorldTile::TerrainChunk");
for( UInt32 iLayer = 0; iLayer < mapChunk->mTextureLayers.size(); iLayer++ )
{
String textureName("Data/");
textureName += adtFile.mTextureNames[mapChunk->mTextureLayers[iLayer].mTextureID];
HTexture2D texture(textureName);
Texture2D* alpha = NULL;
if( iLayer != 0 )
{
alpha = Cast<Texture2D>(Texture2D::StaticClass()->AllocateNew( "AlphaMap" ));
alpha->Create( mapChunk->mAlphaMaps[iLayer-1], true );
alpha->Init();
alpha->SetWrapMode( Texture::Wrap_S, Texture::Wrap_Clamp );
alpha->SetWrapMode( Texture::Wrap_T, Texture::Wrap_Clamp );
alpha->SetMinFilter( Texture::MinFilter_Linear );
alpha->SetMagFilter( Texture::MagFilter_Linear );
}
newChunk->AddTextureLayer( texture, alpha );
}
UInt32 detailedStripSize = (16*18 + 7*2 + 8*2);
UInt32 normalStripSize = 158;
// Build index buffer
newChunk->GetHiResTriangles().Allocate( TriangleBatch::TriangleStrip, detailedStripSize );
newChunk->GetLowResTriangles().Allocate( TriangleBatch::TriangleStrip, normalStripSize );
UInt16* ptrHiIndices = newChunk->GetHiResTriangles().GetIndices();
UInt16* ptrLoIndices = newChunk->GetLowResTriangles().GetIndices();
for( int row = 0; row < 8; row++ )
{
UInt32 topRow = verticesOffset + row*(9+8);
UInt32 detailrow = verticesOffset + row*(9+8) + 9;
UInt32 nextRow = verticesOffset + (row+1)*(9+8);
if( row > 0 )
{
*ptrHiIndices++ = topRow + 0; // jump end
*ptrLoIndices++ = topRow + 0;
}
for( int col = 0; col < 8; col++ )
{
*ptrHiIndices++ = topRow + col;
*ptrHiIndices++ = detailrow + col;
*ptrLoIndices++ = topRow + col;
*ptrLoIndices++ = nextRow + col;
}
*ptrHiIndices++ = topRow + 8;
*ptrHiIndices++ = nextRow + 8;
*ptrHiIndices++ = nextRow + 8; // jump start
*ptrHiIndices++ = topRow + 0; // jump end
*ptrHiIndices++ = topRow + 0;
*ptrLoIndices++ = topRow + 8;
*ptrLoIndices++ = nextRow + 8;
for( int col = 0; col < 8; col++ )
{
*ptrHiIndices++ = nextRow + col;
*ptrHiIndices++ = detailrow + col;
}
if( row < 8 )
*ptrHiIndices++ = nextRow + 8;
if( row < 7 )
{
*ptrHiIndices++ = nextRow + 8; // jump start
*ptrLoIndices++ = nextRow + 8;
}
}
verticesOffset += 9*9 + 8*8;
worldTile->GetTerrainChunks()[iChunk] = newChunk;
}
return (Resource*)worldTile;
}
ModelBrowserTool::ModelBrowserTool() :
mModelBrowserWindow(NULL),
mModel(NULL)
{
mModel = GD_NEW(Model3D, this, "Model3D");
}
GDEXP extern IGraphics* CreateIGraphicsInstance()
{
return GD_NEW(IGraphicsOpenGL);
}
GDEXP IDateTime* CreateIDateTimeInstance()
{
return GD_NEW(IDateTimeMicrosoft);
}
SoundData* WavReader::Read(const String& pFileName)
{
SoundData* newSoundData = GD_NEW(SoundData, this, "SoundData");
newSoundData->SetFileName(pFileName);
Char identifier[5];
identifier[4] = '\0';
// Open the file stream.
std::ifstream fileStream(pFileName.c_str(), std::ios::in | std::ios::binary);
// Read "RIFF"
fileStream.read(identifier, 4);
if(strcmp(identifier, "RIFF") != 0)
throw ResourceImportException( String("The wav file should start with RIFF"), Here );
// Read the total length (filesize - 8).
Int32 fileDataSize;
fileStream.read((Char*)(&fileDataSize), 4);
fileDataSize += 8;
newSoundData->SetFileDataSize(fileDataSize);
// Read "WAVE".
fileStream.read(identifier, 4);
if(strcmp(identifier, "WAVE") != 0)
throw ResourceImportException( String("The wav file should contain the WAVE identifier."), Here );
// Read "fmt_"
fileStream.read(identifier, 4);
if(strcmp(identifier, "fmt ") != 0)
throw ResourceImportException( String("The wav file should contain the fmt_ identifier."), Here );
// Read the Length of the format chunk.
Int32 chunkFileSize;
fileStream.read((Char*)(&chunkFileSize), 4);
// Read a drummy short.
Int16 dummyShort;
fileStream.read((Char*)(&dummyShort), 2);
// Read the number of channels.
Int16 nbChannels;
fileStream.read((Char*)(&nbChannels), 2);
newSoundData->SetNbChannels(nbChannels);
// Read the sample rate.
Int32 sampleRate;
fileStream.read((Char*)(&sampleRate), 4);
newSoundData->SetSampleRate(sampleRate);
// Read the bytes per second.
Int32 bytesPerSecond;
fileStream.read((Char*)(&bytesPerSecond), 4);
newSoundData->SetBytesPerSecond(bytesPerSecond);
// Read the bytes per sample.
Int16 bytesPerSample;
fileStream.read((Char*)(&bytesPerSample), 2);
newSoundData->SetBytesPerSample(bytesPerSample);
// Read the bits per sample.
Int16 bitsPerSample;
fileStream.read((Char*)(&bitsPerSample), 2);
newSoundData->SetBitsPerSample(bitsPerSample);
// Read "data"
fileStream.read(identifier, 4);
if(strcmp(identifier, "data") != 0)
throw ResourceImportException( String("The wav file should contain the data identifier."), Here );
// Read the size of sound data.
Int32 soundDataSize;
fileStream.read((Char*)(&soundDataSize), 4);
newSoundData->SetSoundDataSize(soundDataSize);
newSoundData->SetSoundDataOffset(44);
// Read the data itself.
fileStream.seekg(0, std::ios::beg);
Char* data = GD_NEW_ARRAY(Char, fileDataSize + 1, this, "Data");
data[fileDataSize] = '\0';
fileStream.read(data, fileDataSize);
newSoundData->SetFileData(data);
fileStream.close();
return newSoundData;
}
