xaymar/BlitzNext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Blitz3D: Reformatting and more optimizations

Browse Source
This commit is contained in:
Michael Fabian Dirks
2017-04-09 05:35:18 +02:00
parent a5f409755e
commit 11cc383e7b
18 changed files with 743 additions and 695 deletions
Download Patch File Download Diff File Expand all files Collapse all files
RuntimeLib/bbgraphics.cpp
+2 -2
View File
@@ -31,7 +31,7 @@ private:
}; };
//degrees to radians //degrees to radians
static const float dtor = 0.0174532925199432957692369076848861f; static const float s_degreesToRadians = 0.0174532925199432957692369076848861f;
static int gx_driver; //current graphics driver static int gx_driver; //current graphics driver
@@ -992,7 +992,7 @@ void bbResizeImage(bbImage *i, float w, float h) {
void bbRotateImage(bbImage *i, float d) { void bbRotateImage(bbImage *i, float d) {
debugImage(i); debugImage(i);
d *= -dtor; d *= -s_degreesToRadians;
bbTFormImage(i, cos(d), -sin(d), sin(d), cos(d)); bbTFormImage(i, cos(d), -sin(d), sin(d), cos(d));
} }
RuntimeLib/bbmath.cpp
+9 -9
View File
@@ -8,16 +8,16 @@ static const int RND_M=2147483647;
static const int RND_Q=44488; static const int RND_Q=44488;
static const int RND_R=3399; static const int RND_R=3399;
static const float dtor=0.0174532925199432957692369076848861f; static const float s_degreesToRadians=0.0174532925199432957692369076848861f;
static const float rtod=57.2957795130823208767981548141052f; static const float s_radiansToDegrees=57.2957795130823208767981548141052f;
float bbSin( float n ){ return (float)sin(n*dtor); } float bbSin( float n ){ return (float)sin(n*s_degreesToRadians); }
float bbCos( float n ){ return (float)cos(n*dtor); } float bbCos( float n ){ return (float)cos(n*s_degreesToRadians); }
float bbTan( float n ){ return (float)tan(n*dtor); } float bbTan( float n ){ return (float)tan(n*s_degreesToRadians); }
float bbASin( float n ){ return (float)asin(n)*rtod; } float bbASin( float n ){ return (float)asin(n)*s_radiansToDegrees; }
float bbACos( float n ){ return (float)acos(n)*rtod; } float bbACos( float n ){ return (float)acos(n)*s_radiansToDegrees; }
float bbATan( float n ){ return (float)atan(n)*rtod; } float bbATan( float n ){ return (float)atan(n)*s_radiansToDegrees; }
float bbATan2( float n,float t ){ return (float)atan2(n,t)*rtod; } float bbATan2( float n,float t ){ return (float)atan2(n,t)*s_radiansToDegrees; }
float bbSqr( float n ){ return (float)sqrt(n); } float bbSqr( float n ){ return (float)sqrt(n); }
float bbFloor( float n ){ return (float)floor(n); } float bbFloor( float n ){ return (float)floor(n); }
float bbCeil( float n ){ return (float)ceil(n); } float bbCeil( float n ){ return (float)ceil(n); }
blitz3d/animator.cpp
+10 -10
View File
@@ -35,7 +35,7 @@ void Animator::reset(){
void Animator::addObjs( Object *obj ){ void Animator::addObjs( Object *obj ){
_objs.push_back( obj ); _objs.push_back( obj );
for( Entity *e=obj->children();e;e=e->successor() ){ for( Entity *e=obj->GetChildren();e;e=e->GetSuccessor() ){
addObjs( e->getObject() ); addObjs( e->getObject() );
} }
} }
@@ -87,13 +87,13 @@ void Animator::updateAnim(){
const Animation &keys=_anims[k].keys[_seq]; const Animation &keys=_anims[k].keys[_seq];
if( keys.numPositionKeys() ){ if( keys.numPositionKeys() ){
obj->setLocalPosition( keys.getPosition( _time ) ); obj->SetLocalPosition( keys.getPosition( _time ) );
} }
if( keys.numScaleKeys() ){ if( keys.numScaleKeys() ){
obj->setLocalScale( keys.getScale( _time ) ); obj->SetLocalScale( keys.getScale( _time ) );
} }
if( keys.numRotationKeys() ){ if( keys.numRotationKeys() ){
obj->setLocalRotation( keys.getRotation( _time ) ); obj->SetLocalRotation( keys.getRotation( _time ) );
} }
} }
} }
@@ -105,9 +105,9 @@ void Animator::updateTrans(){
Object *obj=_objs[k]; Object *obj=_objs[k];
const Anim &anim=_anims[k]; const Anim &anim=_anims[k];
if( anim.pos ) obj->setLocalPosition( (anim.dest_pos-anim.src_pos)*_trans_time+anim.src_pos ); if( anim.pos ) obj->SetLocalPosition( (anim.dest_pos-anim.src_pos)*_trans_time+anim.src_pos );
if( anim.scl ) obj->setLocalScale( (anim.dest_scl-anim.src_scl)*_trans_time+anim.src_scl ); if( anim.scl ) obj->SetLocalScale( (anim.dest_scl-anim.src_scl)*_trans_time+anim.src_scl );
if( anim.rot ) obj->setLocalRotation( anim.src_rot.slerpTo( anim.dest_rot,_trans_time ) ); if( anim.rot ) obj->SetLocalRotation( anim.src_rot.slerpTo( anim.dest_rot,_trans_time ) );
} }
} }
@@ -120,15 +120,15 @@ void Animator::beginTrans(){
const Animation &keys=_anims[k].keys[_seq]; const Animation &keys=_anims[k].keys[_seq];
if( anim.pos=!!keys.numPositionKeys() ){ if( anim.pos=!!keys.numPositionKeys() ){
anim.src_pos=obj->getLocalPosition(); anim.src_pos=obj->GetLocalPosition();
anim.dest_pos=keys.getPosition( _time ); anim.dest_pos=keys.getPosition( _time );
} }
if( anim.scl=!!keys.numScaleKeys() ){ if( anim.scl=!!keys.numScaleKeys() ){
anim.src_scl=obj->getLocalScale(); anim.src_scl=obj->GetLocalScale();
anim.dest_scl=keys.getScale( _time ); anim.dest_scl=keys.getScale( _time );
} }
if( anim.rot=!!keys.numRotationKeys() ){ if( anim.rot=!!keys.numRotationKeys() ){
anim.src_rot=obj->getLocalRotation(); anim.src_rot=obj->GetLocalRotation();
anim.dest_rot=keys.getRotation( _time ); anim.dest_rot=keys.getRotation( _time );
} }
} }
blitz3d/blitz3d.vcxproj
+79 -6
View File
@@ -9,6 +9,10 @@
<Configuration>Release</Configuration> <Configuration>Release</Configuration>
<Platform>Win32</Platform> <Platform>Win32</Platform>
</ProjectConfiguration> </ProjectConfiguration>
<ProjectConfiguration Include="RelWithDebInfo|Win32">
<Configuration>RelWithDebInfo</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup> </ItemGroup>
<PropertyGroup Label="Globals"> <PropertyGroup Label="Globals">
<SccProjectName /> <SccProjectName />
@@ -19,7 +23,7 @@
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType> <ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v140</PlatformToolset> <PlatformToolset>v140_xp</PlatformToolset>
<UseOfMfc>false</UseOfMfc> <UseOfMfc>false</UseOfMfc>
<CharacterSet>MultiByte</CharacterSet> <CharacterSet>MultiByte</CharacterSet>
</PropertyGroup> </PropertyGroup>
@@ -28,6 +32,13 @@
<PlatformToolset>v140</PlatformToolset> <PlatformToolset>v140</PlatformToolset>
<UseOfMfc>false</UseOfMfc> <UseOfMfc>false</UseOfMfc>
<CharacterSet>MultiByte</CharacterSet> <CharacterSet>MultiByte</CharacterSet>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v140_xp</PlatformToolset>
<UseOfMfc>false</UseOfMfc>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup> </PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings"> <ImportGroup Label="ExtensionSettings">
@@ -40,22 +51,80 @@
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(VCTargetsPath)Microsoft.Cpp.UpgradeFromVC60.props" /> <Import Project="$(VCTargetsPath)Microsoft.Cpp.UpgradeFromVC60.props" />
</ImportGroup> </ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(VCTargetsPath)Microsoft.Cpp.UpgradeFromVC60.props" />
</ImportGroup>
<PropertyGroup Label="UserMacros" /> <PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<OutDir>..\#Build\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</OutDir> <OutDir>..\#Build\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</OutDir>
<IntDir>..\#Intermediate\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</IntDir> <IntDir>..\#Intermediate\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</IntDir>
<LinkIncremental>false</LinkIncremental> <LinkIncremental>false</LinkIncremental>
<IncludePath>$(DXSDK_DIR)Include\;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath> <IncludePath>C:\Program Files (x86)\Windows Kits\10\Include\10.0.14393.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.14393.0\um;$(IncludePath)</IncludePath>
<LibraryPath>$(DXSDK_DIR)Lib\x86\;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath> <LibraryPath>C:\Program Files (x86)\Windows Kits\10\Lib\10.0.14393.0\um\x86;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">
<OutDir>..\#Build\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</OutDir>
<IntDir>..\#Intermediate\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</IntDir>
<LinkIncremental>false</LinkIncremental>
<IncludePath>C:\Program Files (x86)\Windows Kits\10\Include\10.0.14393.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.14393.0\um;$(IncludePath)</IncludePath>
<LibraryPath>C:\Program Files (x86)\Windows Kits\10\Lib\10.0.14393.0\um\x86;$(LibraryPath)</LibraryPath>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>..\#Build\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</OutDir> <OutDir>..\#Build\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</OutDir>
<IntDir>..\#Intermediate\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</IntDir> <IntDir>..\#Intermediate\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</IntDir>
<LinkIncremental>true</LinkIncremental> <LinkIncremental>true</LinkIncremental>
<IncludePath>$(DXSDK_DIR)Include\;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath> <IncludePath>C:\Program Files (x86)\Windows Kits\10\Include\10.0.14393.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.14393.0\um;$(IncludePath)</IncludePath>
<LibraryPath>$(DXSDK_DIR)Lib\x86\;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath> <LibraryPath>C:\Program Files (x86)\Windows Kits\10\Lib\10.0.14393.0\um\x86;$(LibraryPath)</LibraryPath>
</PropertyGroup> </PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>false</FunctionLevelLinking>
<SuppressStartupBanner>true</SuppressStartupBanner>
<WarningLevel>Level3</WarningLevel>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<ControlFlowGuard>false</ControlFlowGuard>
<ProgramDataBaseFileName>$(IntDir)vc$(PlatformToolsetVersion).pdb</ProgramDataBaseFileName>
<CallingConvention>StdCall</CallingConvention>
<ExceptionHandling>Async</ExceptionHandling>
<RemoveUnreferencedCodeData>false</RemoveUnreferencedCodeData>
<Optimization>Full</Optimization>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<IntrinsicFunctions>true</IntrinsicFunctions>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<OmitFramePointers>true</OmitFramePointers>
<WholeProgramOptimization>true</WholeProgramOptimization>
<StructMemberAlignment>4Bytes</StructMemberAlignment>
<BufferSecurityCheck>false</BufferSecurityCheck>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
<EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
<FloatingPointModel>Fast</FloatingPointModel>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<CompileAsManaged>false</CompileAsManaged>
<SDLCheck>
</SDLCheck>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
<EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
</ClCompile>
<ResourceCompile>
<Culture>0x0409</Culture>
<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ResourceCompile>
<Bscmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
<OutputFile>.\Release\blitz3d.bsc</OutputFile>
</Bscmake>
<Lib>
<SuppressStartupBanner>true</SuppressStartupBanner>
<OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
<TargetMachine>MachineX86</TargetMachine>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">
<ClCompile> <ClCompile>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>false</FunctionLevelLinking> <FunctionLevelLinking>false</FunctionLevelLinking>
@@ -127,7 +196,9 @@
<ClCompile Include="listener.cpp" /> <ClCompile Include="listener.cpp" />
<ClCompile Include="loader_3ds.cpp" /> <ClCompile Include="loader_3ds.cpp" />
<ClCompile Include="loader_b3d.cpp" /> <ClCompile Include="loader_b3d.cpp" />
<ClCompile Include="loader_x.cpp" /> <ClCompile Include="loader_x.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="md2model.cpp" /> <ClCompile Include="md2model.cpp" />
<ClCompile Include="md2norms.cpp" /> <ClCompile Include="md2norms.cpp" />
<ClCompile Include="md2rep.cpp" /> <ClCompile Include="md2rep.cpp" />
@@ -145,7 +216,9 @@
<ClCompile Include="sprite.cpp" /> <ClCompile Include="sprite.cpp" />
<ClCompile Include="std.cpp"> <ClCompile Include="std.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader> <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">Create</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">std.h</PrecompiledHeaderFile> <PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">std.h</PrecompiledHeaderFile>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">std.h</PrecompiledHeaderFile>
</ClCompile> </ClCompile>
<ClCompile Include="surface.cpp" /> <ClCompile Include="surface.cpp" />
<ClCompile Include="terrain.cpp" /> <ClCompile Include="terrain.cpp" />
blitz3d/blitz3d.vcxproj.filters
+3 -3
View File
@@ -50,9 +50,6 @@
<ClCompile Include="loader_b3d.cpp"> <ClCompile Include="loader_b3d.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="loader_x.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="md2model.cpp"> <ClCompile Include="md2model.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
@@ -116,6 +113,9 @@
<ClCompile Include="world.cpp"> <ClCompile Include="world.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="loader_x.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="animation.h"> <ClInclude Include="animation.h">
blitz3d/entity.cpp
+116 -116
View File
@@ -4,194 +4,194 @@
//#include "stats.h" //#include "stats.h"
Entity *Entity::_orphans,*Entity::_last_orphan; Entity *Entity::_orphans, *Entity::_last_orphan;
enum{ enum {
INVALID_LOCALTFORM=1, INVALID_LOCALTFORM = 1,
INVALID_WORLDTFORM=2 INVALID_WORLDTFORM = 2
}; };
void Entity::remove(){ void Entity::RemoveParent() {
if( _parent ){ if (m_parent) {
if( _parent->_children==this ) _parent->_children=_succ; if (m_parent->m_children == this) m_parent->m_children = m_listNext;
if( _parent->_last_child==this ) _parent->_last_child=_pred; if (m_parent->m_last_child == this) m_parent->m_last_child = m_listPrev;
}else{ } else {
if( _orphans==this ) _orphans=_succ; if (_orphans == this) _orphans = m_listNext;
if( _last_orphan==this ) _last_orphan=_pred; if (_last_orphan == this) _last_orphan = m_listPrev;
} }
if( _succ ) _succ->_pred=_pred; if (m_listNext) m_listNext->m_listPrev = m_listPrev;
if( _pred ) _pred->_succ=_succ; if (m_listPrev) m_listPrev->m_listNext = m_listNext;
} }
void Entity::insert(){ void Entity::InsertChildToParent() {
_succ=0; m_listNext = 0;
if( _parent ){ if (m_parent) {
if( _pred=_parent->_last_child ) _pred->_succ=this; if (m_listPrev = m_parent->m_last_child) m_listPrev->m_listNext = this;
else _parent->_children=this; else m_parent->m_children = this;
_parent->_last_child=this; m_parent->m_last_child = this;
}else{ } else {
if( _pred=_last_orphan ) _pred->_succ=this; if (m_listPrev = _last_orphan) m_listPrev->m_listNext = this;
else _orphans=this; else _orphans = this;
_last_orphan=this; _last_orphan = this;
} }
} }
Entity::Entity(): Entity::Entity() :
_succ(0),_pred(0),_parent(0),_children(0),_last_child(0), m_listNext(0), m_listPrev(0), m_parent(0), m_children(0), m_last_child(0),
_visible(true),_enabled(true), m_isVisible(true), m_isEnabled(true),
local_scl(1,1,1), m_localScale(1, 1, 1),
invalid(0){ invalid(0) {
insert(); InsertChildToParent();
} }
Entity::Entity( const Entity &e ): Entity::Entity(const Entity &e) :
_succ(0),_pred(0),_parent(0),_children(0),_last_child(0), m_listNext(0), m_listPrev(0), m_parent(0), m_children(0), m_last_child(0),
_name(e._name),_visible(e._visible),_enabled(e._enabled), m_name(e.m_name), m_isVisible(e.m_isVisible), m_isEnabled(e.m_isEnabled),
local_pos(e.local_pos), m_localPosition(e.m_localPosition),
local_scl(e.local_scl), m_localScale(e.m_localScale),
local_rot(e.local_rot), m_localRotation(e.m_localRotation),
invalid( INVALID_LOCALTFORM|INVALID_WORLDTFORM ){ invalid(INVALID_LOCALTFORM | INVALID_WORLDTFORM) {
insert(); InsertChildToParent();
} }
Entity::~Entity(){ Entity::~Entity() {
while( children() ) delete children(); while (GetChildren()) delete GetChildren();
remove(); RemoveParent();
} }
void Entity::invalidateWorld(){ void Entity::InvalidateWorldTransform() {
if( invalid & INVALID_WORLDTFORM ) return; if (invalid & INVALID_WORLDTFORM) return;
invalid|=INVALID_WORLDTFORM; invalid |= INVALID_WORLDTFORM;
for( Entity *e=_children;e;e=e->_succ ){ for (Entity *e = m_children; e; e = e->m_listNext) {
e->invalidateWorld(); e->InvalidateWorldTransform();
} }
} }
void Entity::invalidateLocal(){ void Entity::invalidateLocal() {
invalid|=INVALID_LOCALTFORM; invalid |= INVALID_LOCALTFORM;
invalidateWorld(); InvalidateWorldTransform();
} }
const Transform &Entity::getLocalTform()const{ const Transform &Entity::GetLocalTransform()const {
if( invalid&INVALID_LOCALTFORM ){ if (invalid&INVALID_LOCALTFORM) {
local_tform.m=Matrix( local_rot ); m_localTransform.m = Matrix(m_localRotation);
local_tform.m.i*=local_scl.x; m_localTransform.m.i *= m_localScale.x;
local_tform.m.j*=local_scl.y; m_localTransform.m.j *= m_localScale.y;
local_tform.m.k*=local_scl.z; m_localTransform.m.k *= m_localScale.z;
local_tform.v=local_pos; m_localTransform.v = m_localPosition;
invalid&=~INVALID_LOCALTFORM; invalid &= ~INVALID_LOCALTFORM;
} }
return local_tform; return m_localTransform;
} }
const Transform &Entity::getWorldTform()const{ const Transform &Entity::GetWorldTransform()const {
if( invalid&INVALID_WORLDTFORM ){ if (invalid&INVALID_WORLDTFORM) {
world_tform=_parent ? _parent->getWorldTform() * getLocalTform() : getLocalTform(); m_worldTransform = m_parent ? m_parent->GetWorldTransform() * GetLocalTransform() : GetLocalTransform();
invalid&=~INVALID_WORLDTFORM; invalid &= ~INVALID_WORLDTFORM;
} }
return world_tform; return m_worldTransform;
} }
void Entity::setParent( Entity *p ){ void Entity::SetParent(Entity *p) {
if( _parent==p ) return; if (m_parent == p) return;
remove(); RemoveParent();
_parent=p; m_parent = p;
insert(); InsertChildToParent();
invalidateWorld(); InvalidateWorldTransform();
} }
void Entity::setName( const string &t ){ void Entity::SetName(const string &t) {
_name=t; m_name = t;
} }
void Entity::setVisible( bool visible ){ void Entity::SetVisible(bool visible) {
_visible=visible; m_isVisible = visible;
} }
void Entity::setEnabled( bool enabled ){ void Entity::SetEnabled(bool enabled) {
_enabled=enabled; m_isEnabled = enabled;
} }
void Entity::enumVisible( vector<Object*> &out ){ void Entity::EnumerateVisible(std::list<Object*> &out) {
if( !_visible ) return; if (!m_isVisible) return;
if( Object *o=getObject() ) out.push_back(o); if (Object *o = getObject()) out.push_back(o);
for( Entity *e=_children;e;e=e->_succ ){ for (Entity *e = m_children; e; e = e->m_listNext) {
e->enumVisible( out ); e->EnumerateVisible(out);
} }
} }
void Entity::enumEnabled( vector<Object*> &out ){ void Entity::EnumerateEnabled(std::list<Object*> &out) {
if( !_enabled ) return; if (!m_isEnabled) return;
if( Object *o=getObject() ) out.push_back(o); if (Object *o = getObject()) out.push_back(o);
for( Entity *e=_children;e;e=e->_succ ){ for (Entity *e = m_children; e; e = e->m_listNext) {
e->enumEnabled( out ); e->EnumerateEnabled(out);
} }
} }
void Entity::setLocalPosition( const Vector &v ){ void Entity::SetLocalPosition(const Vector &v) {
local_pos=v; m_localPosition = v;
invalidateLocal(); invalidateLocal();
} }
void Entity::setLocalScale( const Vector &v ){ void Entity::SetLocalScale(const Vector &v) {
local_scl=v; m_localScale = v;
invalidateLocal(); invalidateLocal();
} }
void Entity::setLocalRotation( const Quat &q ){ void Entity::SetLocalRotation(const Quat &q) {
local_rot=q.normalized(); m_localRotation = q.normalized();
invalidateLocal(); invalidateLocal();
} }
void Entity::setLocalTform( const Transform &t ){ void Entity::SetLocalTransform(const Transform &t) {
local_pos=t.v; m_localPosition = t.v;
local_scl=Vector( t.m.i.length(),t.m.j.length(),t.m.k.length() ); m_localScale = Vector(t.m.i.length(), t.m.j.length(), t.m.k.length());
local_rot=matrixQuat( t.m ); m_localRotation = matrixQuat(t.m);
invalidateLocal(); invalidateLocal();
} }
void Entity::setWorldPosition( const Vector &v ){ void Entity::SetWorldPosition(const Vector &v) {
setLocalPosition( _parent ? -_parent->getWorldTform() * v : v ); SetLocalPosition(m_parent ? -m_parent->GetWorldTransform() * v : v);
} }
void Entity::setWorldScale( const Vector &v ){ void Entity::SetWorldScale(const Vector &v) {
setLocalScale( _parent ? v/_parent->getWorldScale() : v ); SetLocalScale(m_parent ? v / m_parent->GetWorldScale() : v);
} }
void Entity::setWorldRotation( const Quat &q ){ void Entity::SetWorldRotation(const Quat &q) {
setLocalRotation( _parent ? -_parent->getWorldRotation() * q : q ); SetLocalRotation(m_parent ? -m_parent->GetWorldRotation() * q : q);
} }
void Entity::setWorldTform( const Transform &t ){ void Entity::SetWorldTransform(const Transform &t) {
setLocalTform( _parent ? -_parent->getWorldTform() * t : t ); SetLocalTransform(m_parent ? -m_parent->GetWorldTransform() * t : t);
} }
const Vector &Entity::getLocalPosition()const{ const Vector &Entity::GetLocalPosition()const {
return local_pos; return m_localPosition;
} }
const Vector &Entity::getLocalScale()const{ const Vector &Entity::GetLocalScale()const {
return local_scl; return m_localScale;
} }
const Quat &Entity::getLocalRotation()const{ const Quat &Entity::GetLocalRotation()const {
return local_rot; return m_localRotation;
} }
const Vector &Entity::getWorldPosition()const{ const Vector &Entity::GetWorldPosition()const {
return getWorldTform().v; return GetWorldTransform().v;
} }
const Vector &Entity::getWorldScale()const{ const Vector &Entity::GetWorldScale()const {
world_scl=_parent ? _parent->getWorldScale() * local_scl : local_scl; m_worldScale = m_parent ? m_parent->GetWorldScale() * m_localScale : m_localScale;
return world_scl; return m_worldScale;
} }
const Quat &Entity::getWorldRotation()const{ const Quat &Entity::GetWorldRotation()const {
world_rot=_parent ? _parent->getWorldRotation() * local_rot : local_rot; m_worldRotation = m_parent ? m_parent->GetWorldRotation() * m_localRotation : m_localRotation;
return world_rot; return m_worldRotation;
} }
blitz3d/entity.h
+53 -55
View File
@@ -16,86 +16,84 @@ class Listener;
class MeshModel; class MeshModel;
class MD2Model; class MD2Model;
class Entity{ class Entity {
public: public:
Entity(); Entity();
Entity( const Entity &e ); Entity(const Entity &e);
virtual ~Entity(); virtual ~Entity();
virtual Entity *clone()=0; virtual Entity *clone() = 0;
//ugly casts! //ugly casts!
virtual Object *getObject(){ return 0; } virtual Object *getObject() { return nullptr; }
virtual Camera *getCamera(){ return 0; } virtual Camera *getCamera() { return nullptr; }
virtual Light *getLight(){ return 0; } virtual Light *getLight() { return nullptr; }
virtual Model *getModel(){ return 0; } virtual Model *getModel() { return nullptr; }
virtual Mirror *getMirror(){ return 0; } virtual Mirror *getMirror() { return nullptr; }
virtual Listener *getListener(){ return 0; } virtual Listener *getListener() { return nullptr; }
void setName( const std::string &t ); void SetName(const std::string &t);
void setParent( Entity *parent ); std::string getName()const { return m_name; }
void setVisible( bool vis ); void SetParent(Entity *parent);
void setEnabled( bool ena ); Entity *getParent()const { return m_parent; }
bool visible()const{ return _visible; } void SetVisible(bool vis);
bool enabled()const{ return _enabled; } bool IsVisible()const { return m_isVisible; }
void EnumerateVisible(std::list<Object*> &out);
void enumVisible( vector<Object*> &out ); void SetEnabled(bool ena);
void enumEnabled( vector<Object*> &out ); bool IsEnabled()const { return m_isEnabled; }
void EnumerateEnabled(std::list<Object*> &out);
Entity *children()const{ return _children; } void SetLocalPosition(const Vector &v);
Entity *successor()const{ return _succ; } const Vector &GetLocalPosition()const;
void SetLocalScale(const Vector & v);
const Vector &GetLocalScale()const;
void SetLocalRotation(const Quat &q);
const Quat &GetLocalRotation()const;
void SetLocalTransform(const Transform &t);
const Transform &GetLocalTransform()const;
std::string getName()const{ return _name; } void SetWorldPosition(const Vector &v);
Entity *getParent()const{ return _parent; } const Vector &GetWorldPosition()const;
void SetWorldScale(const Vector &v);
const Vector &GetWorldScale()const;
void SetWorldRotation(const Quat &q);
const Quat &GetWorldRotation()const;
void SetWorldTransform(const Transform &t);
const Transform &GetWorldTransform()const;
void setLocalPosition( const Vector &v ); Entity* GetChildren()const { return m_children; }
void setLocalScale( const Vector & v ); Entity* GetSuccessor()const { return m_listNext; }
void setLocalRotation( const Quat &q );
void setLocalTform( const Transform &t );
void setWorldPosition( const Vector &v );
void setWorldScale( const Vector &v );
void setWorldRotation( const Quat &q );
void setWorldTform( const Transform &t );
const Vector &getLocalPosition()const; static Entity* GetEntityOrphans() { return _orphans; }
const Vector &getLocalScale()const;
const Quat &getLocalRotation()const;
const Transform &getLocalTform()const;
const Vector &getWorldPosition()const; private:
const Vector &getWorldScale()const; Entity *m_listNext, *m_listPrev, *m_parent, *m_children, *m_last_child;
const Quat &getWorldRotation()const;
const Transform &getWorldTform()const;
static Entity *orphans(){ return _orphans; } static Entity *_orphans, *_last_orphan;
private: bool m_isVisible, m_isEnabled;
Entity *_succ,*_pred,*_parent,*_children,*_last_child;
static Entity *_orphans,*_last_orphan; std::string m_name;
bool _visible,_enabled;
std::string _name;
mutable int invalid; mutable int invalid;
Quat local_rot; Quat m_localRotation;
Vector local_pos,local_scl; Vector m_localPosition, m_localScale;
mutable Transform local_tform; mutable Transform m_localTransform;
mutable Quat world_rot; mutable Quat m_worldRotation;
mutable Vector world_pos,world_scl; mutable Vector m_worldPosition, m_worldScale;
mutable Transform world_tform; mutable Transform m_worldTransform;
void insert(); void InsertChildToParent();
void remove(); void RemoveParent();
void invalidateLocal(); void invalidateLocal();
void invalidateWorld(); void InvalidateWorldTransform();
}; };
#endif #endif
blitz3d/listener.cpp
+3 -3
View File
@@ -25,10 +25,10 @@ Listener::~Listener(){
void Listener::renderListener(){ void Listener::renderListener(){
if( !gx_audio ) return; if( !gx_audio ) return;
const Vector &pos=getWorldTform().v; const Vector &pos=GetWorldTransform().v;
const Vector &vel=getVelocity(); const Vector &vel=getVelocity();
const Vector &forward=getWorldTform().m.k.normalized(); const Vector &forward=GetWorldTransform().m.k.normalized();
const Vector &up=getWorldTform().m.j.normalized(); const Vector &up=GetWorldTransform().m.j.normalized();
gx_audio->set3dListener( &pos.x,&vel.x,&forward.x,&up.x ); gx_audio->set3dListener( &pos.x,&vel.x,&forward.x,&up.x );
} }
blitz3d/loader_3ds.cpp
+8 -8
View File
@@ -210,7 +210,7 @@ static void parseTriMesh( MeshModel *mesh ){
int k; int k;
mesh->setWorldTform( tform ); mesh->SetWorldTransform( tform );
if( animonly ){ if( animonly ){
MeshLoader::endMesh( 0 ); MeshLoader::endMesh( 0 );
@@ -245,8 +245,8 @@ static void parseObject( MeshModel *root ){
switch( id ){ switch( id ){
case CHUNK_TRIMESH: case CHUNK_TRIMESH:
mesh=new MeshModel(); mesh=new MeshModel();
mesh->setName( name ); mesh->SetName( name );
mesh->setParent( root ); mesh->SetParent( root );
name_map[name]=mesh; name_map[name]=mesh;
parseTriMesh( mesh ); parseTriMesh( mesh );
break; break;
@@ -420,8 +420,8 @@ static void parseMeshInfo( MeshModel *root,float curr_time ){
MeshModel *mesh=0; MeshModel *mesh=0;
if( name=="$$$DUMMY" ){ if( name=="$$$DUMMY" ){
mesh=new MeshModel(); mesh=new MeshModel();
mesh->setName( inst ); mesh->SetName( inst );
mesh->setParent( p ); mesh->SetParent( p );
}else{ }else{
map<string,MeshModel*>::const_iterator it=name_map.find( name ); map<string,MeshModel*>::const_iterator it=name_map.find( name );
if( it==name_map.end() ) return; if( it==name_map.end() ) return;
@@ -431,9 +431,9 @@ static void parseMeshInfo( MeshModel *root,float curr_time ){
mesh->transform( -pivot ); mesh->transform( -pivot );
} }
Transform t= Transform t=
mesh->getWorldTform(); mesh->GetWorldTransform();
mesh->setParent( p ); mesh->SetParent( p );
mesh->setWorldTform( t ); mesh->SetWorldTransform( t );
} }
mesh->setAnimation( anim ); mesh->setAnimation( anim );
blitz3d/loader_b3d.cpp
+5 -5
View File
@@ -289,10 +289,10 @@ static Object *readObject( Object *parent ){
if( !obj ) obj=new MeshModel(); if( !obj ) obj=new MeshModel();
obj->setName( name ); obj->SetName( name );
obj->setLocalPosition( Vector( pos[0],pos[1],pos[2] ) ); obj->SetLocalPosition( Vector( pos[0],pos[1],pos[2] ) );
obj->setLocalScale( Vector( scl[0],scl[1],scl[2] ) ); obj->SetLocalScale( Vector( scl[0],scl[1],scl[2] ) );
obj->setLocalRotation( Quat( rot[0],Vector( rot[1],rot[2],rot[3] ) ) ); obj->SetLocalRotation( Quat( rot[0],Vector( rot[1],rot[2],rot[3] ) ) );
obj->setAnimation( keys ); obj->setAnimation( keys );
if( mesh ){ if( mesh ){
@@ -310,7 +310,7 @@ static Object *readObject( Object *parent ){
obj->setAnimator( new Animator( obj,anim_len ) ); obj->setAnimator( new Animator( obj,anim_len ) );
} }
if( parent ) obj->setParent( parent ); if( parent ) obj->SetParent( parent );
return obj; return obj;
} }
blitz3d/loader_x.cpp
+12 -8
View File
@@ -5,7 +5,11 @@
#include "animation.h" #include "animation.h"
#include "pivot.h" #include "pivot.h"
#include <dxfile.h> #include <windows.h>
//#include <dxfile.h>
#include "../gxruntime/GraphicsRuntime.h"
#include <d3d9types.h>
#include <d3dx9xof.h>
#include <rmxfguid.h> #include <rmxfguid.h>
#include <rmxftmpl.h> #include <rmxftmpl.h>
@@ -17,7 +21,7 @@ static bool conv,flip_tris;
static Transform conv_tform; static Transform conv_tform;
static bool collapse,animonly; static bool collapse,animonly;
static void parseAnimKey( IDirectXFileData *fileData,MeshModel *e ){ static void parseAnimKey(ID3DXFileData *fileData, MeshModel *e) {
DWORD sz;int *data; DWORD sz;int *data;
if( fileData->GetData( 0,&sz,(void**)&data )<0 ) return; if( fileData->GetData( 0,&sz,(void**)&data )<0 ) return;
@@ -66,7 +70,7 @@ static void parseAnimKey( IDirectXFileData *fileData,MeshModel *e ){
e->setAnimation( anim ); e->setAnimation( anim );
} }
static void parseAnim( IDirectXFileData *fileData ){ static void parseAnim(ID3DXFileData *fileData) {
const GUID *guid; const GUID *guid;
IDirectXFileObject *childObj; IDirectXFileObject *childObj;
IDirectXFileData *childData; IDirectXFileData *childData;
@@ -270,7 +274,7 @@ static void parseMesh( IDirectXFileData *fileData,MeshModel *mesh ){
} }
if( !mats.size() ) mats.push_back( Brush() ); if( !mats.size() ) mats.push_back( Brush() );
for( k=0;k<faces.size();++k ){ for( size_t k=0;k<faces.size();++k ){
const FaceX &f=faces[k]; const FaceX &f=faces[k];
int *data=f.data; int *data=f.data;
int cnt=*data++;if( cnt<3 ) continue; int cnt=*data++;if( cnt<3 ) continue;
@@ -299,7 +303,7 @@ static MeshModel *parseFrame( IDirectXFileData *fileData ){
char name[80];DWORD len=80; char name[80];DWORD len=80;
if( fileData->GetName( name,&len )<0 ) return e; if( fileData->GetName( name,&len )<0 ) return e;
e->setName( name ); e->SetName( name );
frames_map[name]=e; frames_map[name]=e;
//iterate through child objects... //iterate through child objects...
@@ -315,13 +319,13 @@ static MeshModel *parseFrame( IDirectXFileData *fileData ){
Vector( data->_31,data->_32,data->_33 ) ), Vector( data->_31,data->_32,data->_33 ) ),
Vector( data->_41,data->_42,data->_43 ) ); Vector( data->_41,data->_42,data->_43 ) );
if( conv ) tform=conv_tform * tform * -conv_tform; if( conv ) tform=conv_tform * tform * -conv_tform;
e->setLocalTform( tform ); e->SetLocalTransform( tform );
} }
}else if( *guid==TID_D3DRMMesh ){ }else if( *guid==TID_D3DRMMesh ){
if( !animonly ) parseMesh( childData,e ); if( !animonly ) parseMesh( childData,e );
}else if( *guid==TID_D3DRMFrame ){ }else if( *guid==TID_D3DRMFrame ){
MeshModel *t=parseFrame( childData ); MeshModel *t=parseFrame( childData );
t->setParent( e ); t->SetParent( e );
} }
} }
childData->Release(); childData->Release();
@@ -354,7 +358,7 @@ static MeshModel *parseFile( const string &file ){
if( !animonly) parseMesh( fileData,e ); if( !animonly) parseMesh( fileData,e );
}else if( *guid==TID_D3DRMFrame ){ }else if( *guid==TID_D3DRMFrame ){
MeshModel *t=parseFrame( fileData ); MeshModel *t=parseFrame( fileData );
t->setParent( e ); t->SetParent( e );
}else if( *guid==TID_D3DRMAnimationSet ){ }else if( *guid==TID_D3DRMAnimationSet ){
if( !collapse ) parseAnimSet( fileData ); if( !collapse ) parseAnimSet( fileData );
} }
blitz3d/meshmodel.cpp
+158 -159
View File
@@ -5,169 +5,168 @@
extern gxGraphics *gx_graphics; extern gxGraphics *gx_graphics;
struct MeshModel::Rep : public Surface::Monitor{ struct MeshModel::Rep : public Surface::Monitor {
int ref_cnt; int ref_cnt;
mutable Box box,cullBox; mutable Box box, cullBox;
mutable MeshCollider *collider; mutable MeshCollider *collider;
mutable int box_valid,coll_valid,norms_valid; mutable int box_valid, coll_valid, norms_valid;
SurfaceList surfaces; SurfaceList surfaces;
vector<Transform> bone_tforms; vector<Transform> bone_tforms;
Rep(): Rep() :
ref_cnt(1),collider(0),box_valid(-1),coll_valid(-1),norms_valid(-1){ ref_cnt(1), collider(0), box_valid(-1), coll_valid(-1), norms_valid(-1) {
geom_changes=brush_changes=0; geom_changes = brush_changes = 0;
} }
~Rep(){ ~Rep() {
delete collider; delete collider;
for( int k=0;k<surfaces.size();++k ) delete surfaces[k]; for (int k = 0; k < surfaces.size(); ++k) delete surfaces[k];
} }
Surface *createSurface( const Brush &b ){ Surface *createSurface(const Brush &b) {
Surface *t=new Surface( this ); Surface *t = new Surface(this);
surfaces.push_back( t ); surfaces.push_back(t);
t->setBrush( b ); t->setBrush(b);
return t; return t;
} }
Surface *findSurface( const Brush &b ){ Surface *findSurface(const Brush &b) {
for( int k=0;k<surfaces.size();++k ){ for (int k = 0; k < surfaces.size(); ++k) {
Surface *s=surfaces[k]; Surface *s = surfaces[k];
if( s->getBrush()<b || b<s->getBrush() ) continue; if (s->getBrush() < b || b < s->getBrush()) continue;
return s; return s;
} }
return 0; return 0;
} }
void paint( const Brush &b ){ void paint(const Brush &b) {
for( int k=0;k<surfaces.size();++k ){ for (int k = 0; k < surfaces.size(); ++k) {
Surface *s=surfaces[k]; Surface *s = surfaces[k];
s->setBrush( b ); s->setBrush(b);
} }
} }
void add( Rep *t ){ void add(Rep *t) {
if( cullBox.empty() && !t->cullBox.empty() ){ if (cullBox.empty() && !t->cullBox.empty()) {
setCullBox( t->cullBox ); setCullBox(t->cullBox);
} }
for( int k=0;k<t->surfaces.size();++k ){ for (int k = 0; k < t->surfaces.size(); ++k) {
Surface *src=t->surfaces[k]; Surface *src = t->surfaces[k];
Surface *dest=findSurface( src->getBrush() ); Surface *dest = findSurface(src->getBrush());
if( !dest ) dest=createSurface( src->getBrush() ); if (!dest) dest = createSurface(src->getBrush());
int j; int j;
for( j=0;j<src->numTriangles();++j ){ for (j = 0; j < src->numTriangles(); ++j) {
Surface::Triangle t=src->getTriangle( j ); Surface::Triangle t = src->getTriangle(j);
t.verts[0]+=dest->numVertices(); t.verts[0] += dest->numVertices();
t.verts[1]+=dest->numVertices(); t.verts[1] += dest->numVertices();
t.verts[2]+=dest->numVertices(); t.verts[2] += dest->numVertices();
dest->addTriangle( t ); dest->addTriangle(t);
} }
for( j=0;j<src->numVertices();++j ){ for (j = 0; j < src->numVertices(); ++j) {
dest->addVertex( src->getVertex( j ) ); dest->addVertex(src->getVertex(j));
} }
} }
} }
void transform( const Transform &t ){ void transform(const Transform &t) {
Matrix co=t.m.cofactor(); Matrix co = t.m.cofactor();
for( int k=0;k<surfaces.size();++k ){ for (int k = 0; k < surfaces.size(); ++k) {
Surface *s=surfaces[k]; Surface *s = surfaces[k];
for( int j=0;j<s->numVertices();++j ){ for (int j = 0; j < s->numVertices(); ++j) {
const Vector &v=s->getVertex(j).coords; const Vector &v = s->getVertex(j).coords;
const Vector &n=s->getVertex(j).normal; const Vector &n = s->getVertex(j).normal;
s->setCoords( j,t*v ); s->setCoords(j, t*v);
s->setNormal( j,co*n ); s->setNormal(j, co*n);
} }
} }
} }
void flip(){ void flip() {
for( int k=0;k<surfaces.size();++k ){ for (int k = 0; k < surfaces.size(); ++k) {
Surface *s=surfaces[k]; Surface *s = surfaces[k];
int j; int j;
for( j=0;j<s->numVertices();++j ){ for (j = 0; j < s->numVertices(); ++j) {
s->setNormal( j,-s->getVertex(j).normal ); s->setNormal(j, -s->getVertex(j).normal);
} }
for( j=0;j<s->numTriangles();++j ){ for (j = 0; j < s->numTriangles(); ++j) {
Surface::Triangle t=s->getTriangle(j); Surface::Triangle t = s->getTriangle(j);
std::swap( t.verts[1],t.verts[2] ); std::swap(t.verts[1], t.verts[2]);
s->setTriangle( j,t ); s->setTriangle(j, t);
} }
} }
} }
void setCullBox( const Box &t ){ void setCullBox(const Box &t) {
cullBox=t; cullBox = t;
} }
void updateNormals(){ void updateNormals() {
if( norms_valid!=geom_changes ){ if (norms_valid != geom_changes) {
for( int k=0;k<surfaces.size();++k ){ for (int k = 0; k < surfaces.size(); ++k) {
Surface *s=surfaces[k]; Surface *s = surfaces[k];
s->updateNormals(); s->updateNormals();
} }
norms_valid=geom_changes; norms_valid = geom_changes;
} }
} }
const Box &getBox()const{ const Box &getBox()const {
if( box_valid!=geom_changes ){ if (box_valid != geom_changes) {
box.clear(); box.clear();
for( int k=0;k<surfaces.size();++k ){ for (int k = 0; k < surfaces.size(); ++k) {
Surface *s=surfaces[k]; Surface *s = surfaces[k];
for( int j=0;j<s->numVertices();++j ){ for (int j = 0; j < s->numVertices(); ++j) {
box.update( s->getVertex(j).coords ); box.update(s->getVertex(j).coords);
} }
} }
box_valid=geom_changes; box_valid = geom_changes;
} }
return box; return box;
} }
const Box &getCullBox()const{ const Box &getCullBox()const {
return cullBox.empty() ? getBox() : cullBox; return cullBox.empty() ? getBox() : cullBox;
} }
MeshCollider *getCollider()const{ MeshCollider *getCollider()const {
if( coll_valid!=geom_changes ){ if (coll_valid != geom_changes) {
delete collider; delete collider;
vector<MeshCollider::Vertex> verts; vector<MeshCollider::Vertex> verts;
vector<MeshCollider::Triangle> tris; vector<MeshCollider::Triangle> tris;
for( int k=0;k<surfaces.size();++k ){ for (int k = 0; k < surfaces.size(); ++k) {
Surface *s=surfaces[k]; Surface *s = surfaces[k];
int j; int j;
for( j=0;j<s->numTriangles();++j ){ for (j = 0; j < s->numTriangles(); ++j) {
MeshCollider::Triangle q; MeshCollider::Triangle q;
q.verts[0]=s->getTriangle(j).verts[0]+verts.size(); q.verts[0] = s->getTriangle(j).verts[0] + verts.size();
q.verts[1]=s->getTriangle(j).verts[1]+verts.size(); q.verts[1] = s->getTriangle(j).verts[1] + verts.size();
q.verts[2]=s->getTriangle(j).verts[2]+verts.size(); q.verts[2] = s->getTriangle(j).verts[2] + verts.size();
q.surface=s; q.surface = s;
q.index=j; q.index = j;
tris.push_back( q ); tris.push_back(q);
} }
for( j=0;j<s->numVertices();++j ){ for (j = 0; j < s->numVertices(); ++j) {
MeshCollider::Vertex q; MeshCollider::Vertex q;
q.coords=s->getVertex(j).coords; q.coords = s->getVertex(j).coords;
verts.push_back( q ); verts.push_back(q);
} }
} }
collider=new MeshCollider( verts,tris ); collider = new MeshCollider(verts, tris);
coll_valid=geom_changes; coll_valid = geom_changes;
} }
return collider; return collider;
} }
}; };
MeshModel::MeshModel(): MeshModel::MeshModel() :
rep( new Rep() ),brush_changes(0){ rep(new Rep()), brush_changes(0) {}
}
MeshModel::MeshModel( const MeshModel &t ):Model( t ), MeshModel::MeshModel(const MeshModel &t) : Model(t),
rep( t.rep ),brush_changes( rep->brush_changes-1 ){ rep(t.rep), brush_changes(rep->brush_changes - 1) {
++rep->ref_cnt; ++rep->ref_cnt;
surf_bones.resize( t.surf_bones.size() ); surf_bones.resize(t.surf_bones.size());
/* /*
if( t.surf_bones.size() ){ if( t.surf_bones.size() ){
surf_bones.resize( t.surf_bones.size() ); surf_bones.resize( t.surf_bones.size() );
@@ -178,144 +177,144 @@ rep( t.rep ),brush_changes( rep->brush_changes-1 ){
*/ */
} }
MeshModel::~MeshModel(){ MeshModel::~MeshModel() {
if( !--rep->ref_cnt ) delete rep; if (!--rep->ref_cnt) delete rep;
} }
void MeshModel::updateNormals(){ void MeshModel::updateNormals() {
rep->updateNormals(); rep->updateNormals();
} }
void MeshModel::setCullBox( const Box &box ){ void MeshModel::setCullBox(const Box &box) {
rep->setCullBox( box ); rep->setCullBox(box);
} }
void MeshModel::setRenderBrush( const Brush &b ){ void MeshModel::setRenderBrush(const Brush &b) {
--brush_changes; --brush_changes;
render_brush=b; render_brush = b;
} }
void MeshModel::createBones(){ void MeshModel::createBones() {
setRenderSpace( RENDER_SPACE_WORLD ); setRenderSpace(RENDER_SPACE_WORLD);
const vector<Object*> &bones=getAnimator()->getObjects(); const vector<Object*> &bones = getAnimator()->getObjects();
surf_bones.resize( bones.size() ); surf_bones.resize(bones.size());
rep->bone_tforms.resize( bones.size() ); rep->bone_tforms.resize(bones.size());
for( int k=0;k<bones.size();++k ){ for (int k = 0; k < bones.size(); ++k) {
rep->bone_tforms[k]=-bones[k]->getWorldTform(); rep->bone_tforms[k] = -bones[k]->GetWorldTransform();
} }
} }
bool MeshModel::render( const RenderContext &rc ){ bool MeshModel::render(const RenderContext &rc) {
const Box &b=rep->getCullBox(); const Box &b = rep->getCullBox();
if( b.empty() ) return false; if (b.empty()) return false;
static Frustum model_frustum; static Frustum model_frustum;
new( &model_frustum ) Frustum( rc.getWorldFrustum(),-getRenderTform() ); new(&model_frustum) Frustum(rc.getWorldFrustum(), -getRenderTform());
if( !model_frustum.cull( b ) ) return false; if (!model_frustum.cull(b)) return false;
if( brush_changes!=rep->brush_changes ){ if (brush_changes != rep->brush_changes) {
brushes.clear(); brushes.clear();
for( int k=0;k<rep->surfaces.size();++k ){ for (int k = 0; k < rep->surfaces.size(); ++k) {
Surface *s=rep->surfaces[k]; Surface *s = rep->surfaces[k];
brushes.push_back( Brush( s->getBrush(),render_brush ) ); brushes.push_back(Brush(s->getBrush(), render_brush));
} }
brush_changes=rep->brush_changes; brush_changes = rep->brush_changes;
} }
if( !surf_bones.size() ){ if (!surf_bones.size()) {
for( int k=0;k<rep->surfaces.size();++k ){ for (int k = 0; k < rep->surfaces.size(); ++k) {
Surface *s=rep->surfaces[k]; Surface *s = rep->surfaces[k];
if( gxMesh *mesh=s->getMesh() ){ if (gxMesh *mesh = s->getMesh()) {
enqueue( mesh,0,s->numVertices(),0,s->numTriangles(),brushes[k] ); enqueue(mesh, 0, s->numVertices(), 0, s->numTriangles(), brushes[k]);
} }
} }
return false; return false;
} }
//OK, its boned! //OK, its boned!
const vector<Object*> &bones=getAnimator()->getObjects(); const vector<Object*> &bones = getAnimator()->getObjects();
int k; int k;
for( k=0;k<bones.size();++k ){ for (k = 0; k < bones.size(); ++k) {
Transform t= Transform t =
bones[k]->getRenderTform() * rep->bone_tforms[k]; bones[k]->getRenderTform() * rep->bone_tforms[k];
surf_bones[k].coord_tform=t; surf_bones[k].coord_tform = t;
surf_bones[k].normal_tform=t.m.cofactor(); surf_bones[k].normal_tform = t.m.cofactor();
} }
bool trans=false; bool trans = false;
for( k=0;k<rep->surfaces.size();++k ){ for (k = 0; k < rep->surfaces.size(); ++k) {
Surface *s=rep->surfaces[k]; Surface *s = rep->surfaces[k];
if( brushes[k].getBlend()==gxScene::BLEND_REPLACE ){ if (brushes[k].getBlend() == gxScene::BLEND_REPLACE) {
if( gxMesh *mesh=s->getMesh( surf_bones ) ){ if (gxMesh *mesh = s->getMesh(surf_bones)) {
enqueue( mesh,0,s->numVertices(),0,s->numTriangles(),brushes[k] ); enqueue(mesh, 0, s->numVertices(), 0, s->numTriangles(), brushes[k]);
} }
}else{ } else {
trans=true; trans = true;
} }
} }
return trans; return trans;
} }
void MeshModel::renderQueue( int type ){ void MeshModel::renderQueue(int type) {
if( type==QUEUE_TRANSPARENT && surf_bones.size() ){ if (type == QUEUE_TRANSPARENT && surf_bones.size()) {
for( int k=0;k<rep->surfaces.size();++k ){ for (int k = 0; k < rep->surfaces.size(); ++k) {
Surface *s=rep->surfaces[k]; Surface *s = rep->surfaces[k];
if( brushes[k].getBlend()!=gxScene::BLEND_REPLACE ){ if (brushes[k].getBlend() != gxScene::BLEND_REPLACE) {
if( gxMesh *mesh=s->getMesh( surf_bones ) ){ if (gxMesh *mesh = s->getMesh(surf_bones)) {
enqueue( mesh,0,s->numVertices(),0,s->numTriangles(),brushes[k] ); enqueue(mesh, 0, s->numVertices(), 0, s->numTriangles(), brushes[k]);
} }
} }
} }
} }
Model::renderQueue( type ); Model::renderQueue(type);
} }
Surface *MeshModel::createSurface( const Brush &b ){ Surface *MeshModel::createSurface(const Brush &b) {
return rep->createSurface( b ); return rep->createSurface(b);
--brush_changes; --brush_changes;
} }
void MeshModel::flipTriangles(){ void MeshModel::flipTriangles() {
rep->flip(); rep->flip();
} }
void MeshModel::transform( const Transform &t ){ void MeshModel::transform(const Transform &t) {
rep->transform( t ); rep->transform(t);
} }
void MeshModel::add( const MeshModel &t ){ void MeshModel::add(const MeshModel &t) {
rep->add( t.rep ); rep->add(t.rep);
} }
const MeshModel::SurfaceList &MeshModel::getSurfaces()const{ const MeshModel::SurfaceList &MeshModel::getSurfaces()const {
return rep->surfaces; return rep->surfaces;
} }
void MeshModel::paint( const Brush &b ){ void MeshModel::paint(const Brush &b) {
rep->paint( b ); rep->paint(b);
} }
const Box &MeshModel::getBox()const{ const Box &MeshModel::getBox()const {
return rep->getBox(); return rep->getBox();
} }
MeshCollider *MeshModel::getCollider()const{ MeshCollider *MeshModel::getCollider()const {
return rep->getCollider(); return rep->getCollider();
} }
Surface *MeshModel::findSurface( const Brush &b )const{ Surface *MeshModel::findSurface(const Brush &b)const {
return rep->findSurface( b ); return rep->findSurface(b);
} }
bool MeshModel::collide( const Line &line,float radius,Collision *curr_coll,const Transform &t ){ bool MeshModel::collide(const Line &line, float radius, Collision *curr_coll, const Transform &t) {
return getCollider()->collide( line,radius,curr_coll,t ); return getCollider()->collide(line, radius, curr_coll, t);
} }
bool MeshModel::intersects( const MeshModel &m )const{ bool MeshModel::intersects(const MeshModel &m)const {
return getCollider()->intersects( *m.getCollider(),-m.getWorldTform()*getWorldTform() ); return getCollider()->intersects(*m.getCollider(), -m.GetWorldTransform()*GetWorldTransform());
} }
blitz3d/object.cpp
+14 -14
View File
@@ -27,9 +27,9 @@ Object::~Object(){
Object *Object::copy(){ Object *Object::copy(){
last_copy=clone()->getObject(); last_copy=clone()->getObject();
for( Entity *e=children();e;e=e->successor() ){ for( Entity *e=GetChildren();e;e=e->GetSuccessor() ){
Object *cpy=e->getObject()->copy(); Object *cpy=e->getObject()->copy();
cpy->setParent( last_copy ); cpy->SetParent( last_copy );
} }
if( animator ) last_copy->setAnimator( new Animator( animator ) ); if( animator ) last_copy->setAnimator( new Animator( animator ) );
return last_copy; return last_copy;
@@ -38,7 +38,7 @@ Object *Object::copy(){
void Object::reset(){ void Object::reset(){
colls.clear(); colls.clear();
velocity=Vector(); velocity=Vector();
prev_tform=getWorldTform(); prev_tform=GetWorldTransform();
} }
void Object::setCollisionType( int type ){ void Object::setCollisionType( int type ){
@@ -73,26 +73,26 @@ void Object::addCollision( const ObjCollision *c ){
} }
void Object::endUpdate(){ void Object::endUpdate(){
velocity=(getWorldTform().v-prev_tform.v)/elapsed; velocity=(GetWorldTransform().v-prev_tform.v)/elapsed;
prev_tform=getWorldTform(); prev_tform=GetWorldTransform();
} }
void Object::capture(){ void Object::capture(){
capt_pos=getLocalPosition(); capt_pos=GetLocalPosition();
capt_scl=getLocalScale(); capt_scl=GetLocalScale();
capt_rot=getLocalRotation(); capt_rot=GetLocalRotation();
captured=true; captured=true;
} }
bool Object::beginRender( float tween ){ bool Object::beginRender( float tween ){
updateSounds(); updateSounds();
if( tween==1 || !captured ){ if( tween==1 || !captured ){
render_tform=getWorldTform(); render_tform=GetWorldTransform();
render_tform_valid=true; render_tform_valid=true;
}else{ }else{
Vector pos=(getLocalPosition()-capt_pos)*tween+capt_pos; Vector pos=(GetLocalPosition()-capt_pos)*tween+capt_pos;
Vector scl=(getLocalScale()-capt_scl)*tween+capt_scl; Vector scl=(GetLocalScale()-capt_scl)*tween+capt_scl;
Quat rot=capt_rot.slerpTo( getLocalRotation(),tween ); Quat rot=capt_rot.slerpTo( GetLocalRotation(),tween );
tween_tform.m=Matrix( rot ); tween_tform.m=Matrix( rot );
tween_tform.m.i*=scl.x; tween_tform.m.i*=scl.x;
tween_tform.m.j*=scl.y; tween_tform.m.j*=scl.y;
@@ -143,7 +143,7 @@ const Transform &Object::getPrevWorldTform()const{
gxChannel *Object::emitSound( gxSound *sound ){ gxChannel *Object::emitSound( gxSound *sound ){
if( !sound ) return 0; if( !sound ) return 0;
gxChannel *chan=sound->play3d( &getWorldTform().v.x,&velocity.x ); gxChannel *chan=sound->play3d( &GetWorldTransform().v.x,&velocity.x );
for( int k=0;k<channels.size();++k ){ for( int k=0;k<channels.size();++k ){
if( chan==channels[k] ) return chan; if( chan==channels[k] ) return chan;
if( !channels[k] ) return channels[k]=chan; if( !channels[k] ) return channels[k]=chan;
@@ -155,7 +155,7 @@ gxChannel *Object::emitSound( gxSound *sound ){
void Object::updateSounds(){ void Object::updateSounds(){
for( int k=0;k<channels.size();++k ){ for( int k=0;k<channels.size();++k ){
if( gxChannel *chan=channels[k] ){ if( gxChannel *chan=channels[k] ){
if( chan->isPlaying() ) chan->set3d( &getWorldTform().v.x,&velocity.x ); if( chan->isPlaying() ) chan->set3d( &GetWorldTransform().v.x,&velocity.x );
else channels[k]=0; else channels[k]=0;
} }
} }
blitz3d/terrainrep.cpp
+2 -2
View File
@@ -40,10 +40,10 @@ struct TerrainRep::Vert{
Vert(){ Vert(){
} }
Vert( int x,int z ):x(x),z(z),v( x,curr->getHeight(x,z),z){ Vert( int x,int z ):x(x),z(z),v( (float)x,curr->getHeight(x,z),(float)z){
src_y=v.y; src_y=v.y;
} }
Vert( int x,int z,float sy ):x(x),z(z),v( x,curr->getHeight(x,z),z ),src_y(sy){ Vert(int x, int z, float sy) :x(x), z(z), v((float)x, curr->getHeight(x, z), (float)z), src_y(sy) {
} }
}; };
blitz3d/texture.cpp
+1 -1
View File
@@ -21,7 +21,7 @@ static vector<Filter> filters;
static int filterFile(const string &t, int flags) { static int filterFile(const string &t, int flags) {
//check filters... //check filters...
string l = tolower(t); string l = tolower(t);
for (int k = 0; k < filters.size(); ++k) { for (size_t k = 0; k < filters.size(); ++k) {
if (l.find(filters[k].t) != string::npos) { if (l.find(filters[k].t) != string::npos) {
flags |= filters[k].flags; flags |= filters[k].flags;
} }
blitz3d/world.cpp
+253 -281
View File
@@ -10,19 +10,19 @@ float stats3d[10];
extern gxScene *gx_scene; extern gxScene *gx_scene;
extern gxRuntime *gx_runtime; extern gxRuntime *gx_runtime;
static vector<Object*> _enabled,_visible; static std::list<Object*> s_objectsEnabled, s_objectsVisible;
static void enumEnabled(){ static void StaticEnumerateEnabled() {
_enabled.clear(); s_objectsEnabled.clear();
for( Entity *e=Entity::orphans();e;e=e->successor() ){ for (Entity *e = Entity::GetEntityOrphans(); e; e = e->GetSuccessor()) {
e->enumEnabled( _enabled ); e->EnumerateEnabled(s_objectsEnabled);
} }
} }
static void enumVisible(){ static void StaticEnumerateVisible() {
_visible.clear(); s_objectsVisible.clear();
for( Entity *e=Entity::orphans();e;e=e->successor() ){ for (Entity *e = Entity::GetEntityOrphans(); e; e = e->GetSuccessor()) {
e->enumVisible( _visible ); e->EnumerateVisible(s_objectsVisible);
} }
} }
@@ -30,113 +30,107 @@ static void enumVisible(){
static vector<Object*> _objsByType[1000]; static vector<Object*> _objsByType[1000];
static vector<ObjCollision*> free_colls,used_colls; static vector<ObjCollision*> free_colls, used_colls;
static ObjCollision *allocObjColl( Object *with,const Vector &coords,const Collision &coll ){ static ObjCollision *allocObjColl(Object *with, const Vector &coords, const Collision &coll) {
ObjCollision *c; ObjCollision *c;
if( free_colls.size() ){ if (free_colls.size()) {
c=free_colls.back(); c = free_colls.back();
free_colls.pop_back(); free_colls.pop_back();
}else{ } else {
c=new ObjCollision(); c = new ObjCollision();
} }
used_colls.push_back( c ); used_colls.push_back(c);
c->with=with; c->with = with;
c->coords=coords; c->coords = coords;
c->collision=coll; c->collision = coll;
return c; return c;
} }
static void collided( Object *src,Object *dest,const Line &line,const Collision &coll,float y_scale ){ static void collided(Object *src, Object *dest, const Line &line, const Collision &coll, float y_scale) {
ObjCollision *c; ObjCollision *c;
const Vector &coords=line*coll.time-coll.normal*src->getCollisionRadii().x; const Vector &coords = line*coll.time - coll.normal*src->getCollisionRadii().x;
c=allocObjColl( dest,coords,coll ); c = allocObjColl(dest, coords, coll);
c->coords.y*=y_scale; c->coords.y *= y_scale;
src->addCollision( c ); src->addCollision(c);
c=allocObjColl( src,coords,coll ); c = allocObjColl(src, coords, coll);
c->coords.y*=y_scale; c->coords.y *= y_scale;
dest->addCollision( c ); dest->addCollision(c);
} }
void World::clearCollisions(){ void World::clearCollisions() {
for( int k=0;k<1000;++k ){ for (int k = 0; k < 1000; ++k) {
_collInfo[k].clear(); _collInfo[k].clear();
} }
} }
void World::addCollision( int src_type,int dst_type,int method,int response ){ void World::addCollision(int src_type, int dst_type, int method, int response) {
vector<CollInfo> &info=_collInfo[src_type]; vector<CollInfo> &info = _collInfo[src_type];
for( int k=0;k<info.size();++k ){ for (size_t k = 0; k < info.size(); ++k) {
const CollInfo &t=info[k]; const CollInfo &t = info[k];
if( dst_type==t.dst_type ) return; if (dst_type == t.dst_type) return;
} }
CollInfo co={dst_type,method,response}; CollInfo co = { dst_type,method,response };
_collInfo[src_type].push_back(co); _collInfo[src_type].push_back(co);
} }
bool World::hitTest( const Line &line,float radius,Object *obj,const Transform &tf,int method,Collision *curr_coll ){ bool World::hitTest(const Line &line, float radius, Object *obj, const Transform &tf, int method, Collision *curr_coll) {
switch( method ){ switch (method) {
case COLLISION_METHOD_SPHERE: case COLLISION_METHOD_SPHERE:
return curr_coll->sphereCollide( line,radius,tf.v,obj->getCollisionRadii().x ); return curr_coll->sphereCollide(line, radius, tf.v, obj->getCollisionRadii().x);
case COLLISION_METHOD_POLYGON: case COLLISION_METHOD_POLYGON:
return obj->collide( line,radius,curr_coll,tf ); return obj->collide(line, radius, curr_coll, tf);
case COLLISION_METHOD_BOX: case COLLISION_METHOD_BOX:
Transform t=tf; Transform t = tf;
t.m.i.normalize();t.m.j.normalize();t.m.k.normalize(); t.m.i.normalize(); t.m.j.normalize(); t.m.k.normalize();
if( curr_coll->boxCollide( ~t*line,radius,obj->getCollisionBox() ) ){ if (curr_coll->boxCollide(~t*line, radius, obj->getCollisionBox())) {
curr_coll->normal=t.m*curr_coll->normal; curr_coll->normal = t.m*curr_coll->normal;
return true; return true;
} }
} }
return false; return false;
} }
bool World::checkLOS( Object *src,Object *dest ){ bool World::CheckLineOfSight(Object *src, Object *dest) {
enumEnabled(); StaticEnumerateEnabled();
Object *coll_obj=0; Object *coll_obj = 0;
Collision curr_coll; Collision curr_coll;
Line line( src->getWorldPosition(),dest->getWorldPosition()-src->getWorldPosition() ); Line line(src->GetWorldPosition(), dest->GetWorldPosition() - src->GetWorldPosition());
vector<Object*>::const_iterator it; for (Object* obj : s_objectsEnabled) {
if (obj == src || obj == dest || !obj->getPickGeometry() || !obj->getObscurer()) continue;
for( it=_enabled.begin();it!=_enabled.end();++it ){ if (hitTest(line, 0, obj, obj->GetWorldTransform(), obj->getPickGeometry(), &curr_coll)) {
Object *obj=*it;
if( obj==src || obj==dest || !obj->getPickGeometry() || !obj->getObscurer() ) continue;
if( hitTest( line,0,obj,obj->getWorldTform(),obj->getPickGeometry(),&curr_coll ) ){
return false; return false;
} }
} }
return true; return true;
} }
Object *World::traceRay( const Line &line,float radius,ObjCollision *curr_coll ){ Object *World::traceRay(const Line &line, float radius, ObjCollision *curr_coll) {
enumEnabled(); StaticEnumerateEnabled();
Object *coll_obj=0; Object *coll_obj = 0;
vector<Object*>::const_iterator it; for (Object* obj : s_objectsEnabled) {
for( it=_enabled.begin();it!=_enabled.end();++it ){
Object *obj=*it;
if( !obj->getPickGeometry() ) continue; if (!obj->getPickGeometry()) continue;
if( hitTest( line,radius,obj,obj->getWorldTform(),obj->getPickGeometry(),&curr_coll->collision ) ){ if (hitTest(line, radius, obj, obj->GetWorldTransform(), obj->getPickGeometry(), &curr_coll->collision)) {
coll_obj=obj; coll_obj = obj;
} }
} }
if( curr_coll->with=coll_obj ){ if (curr_coll->with = coll_obj) {
curr_coll->coords=line*curr_coll->collision.time-curr_coll->collision.normal*radius; curr_coll->coords = line*curr_coll->collision.time - curr_coll->collision.normal*radius;
} }
return coll_obj; return coll_obj;
} }
@@ -144,158 +138,148 @@ Object *World::traceRay( const Line &line,float radius,ObjCollision *curr_coll )
// //
// NEW VERSION // NEW VERSION
// //
void World::collide( Object *src ){ void World::collide(Object *src) {
Vector dv = src->GetWorldTransform().v;
Vector sv = src->getPrevWorldTform().v;
static const int MAX_HITS=10; if (sv == dv) {
if (dv.x != sv.x || dv.y != sv.y || dv.z != sv.z) {
Vector dv=src->getWorldTform().v; src->SetWorldPosition(sv);
Vector sv=src->getPrevWorldTform().v;
if( sv==dv ){
if( dv.x!=sv.x || dv.y!=sv.y || dv.z!=sv.z ){
src->setWorldPosition( sv );
} }
return; return;
} }
Vector panic=sv; Vector panic = sv;
static Transform y_tform; static Transform y_tform;
const Vector &radii=src->getCollisionRadii(); const Vector &radii = src->getCollisionRadii();
float radius=radii.x,inv_y_scale; float radius = radii.x, inv_y_scale;
float y_scale=inv_y_scale=y_tform.m.j.y=1; float y_scale = inv_y_scale = y_tform.m.j.y = 1;
if( radii.x!=radii.y ){ if (radii.x != radii.y) {
y_scale=y_tform.m.j.y=radius/radii.y; y_scale = y_tform.m.j.y = radius / radii.y;
inv_y_scale=1/y_scale; inv_y_scale = 1 / y_scale;
sv.y*=y_scale; sv.y *= y_scale;
dv.y*=y_scale; dv.y *= y_scale;
} }
int n_hit=0; int n_hit = 0;
Plane planes[2]; Plane planes[2];
Line coll_line( sv,dv-sv ); Line coll_line(sv, dv - sv);
Vector dir=coll_line.d; Vector dir = coll_line.d;
float td=coll_line.d.length(); float td = coll_line.d.length();
float td_xz=Vector( coll_line.d.x,0,coll_line.d.z ).length(); float td_xz = Vector(coll_line.d.x, 0, coll_line.d.z).length();
const vector<CollInfo> &collinfos=_collInfo[src->getCollisionType()]; const vector<CollInfo> &collinfos = _collInfo[src->getCollisionType()];
int hits=0;
for(;;){
int hits = 0;
for (;;) {
Collision coll; Collision coll;
Object *coll_obj=0; Object *coll_obj = 0;
vector<CollInfo>::const_iterator coll_it,coll_info; vector<CollInfo>::const_iterator coll_it, coll_info;
for( coll_it=collinfos.begin();coll_it!=collinfos.end();++coll_it ){ for (coll_it = collinfos.begin(); coll_it != collinfos.end(); ++coll_it) {
// const std::list<Object*> &dst_objs = _objsByType[coll_it->dst_type];
for (Object* dst : /*dst_objs*/_objsByType[coll_it->dst_type]) {
vector<Object*>::const_iterator dst_it; if (src == dst) continue;
const vector<Object*> &dst_objs=_objsByType[coll_it->dst_type];
for( dst_it=dst_objs.begin();dst_it!=dst_objs.end();++dst_it ){ const Transform &dst_tform = dst->getPrevWorldTform();
Object *dst=*dst_it; if (y_scale == 1) {
if (hitTest(
if( src==dst ) continue; coll_line, radius, dst, dst_tform,
coll_it->method, &coll)) {
const Transform &dst_tform=dst->getPrevWorldTform(); coll_obj = dst;
coll_info = coll_it;
if( y_scale==1 ){
if( hitTest(
coll_line,radius,dst,dst_tform,
coll_it->method,&coll ) ){
coll_obj=dst;
coll_info=coll_it;
} }
}else{ } else {
if( hitTest( if (hitTest(
coll_line,radius,dst,y_tform * dst_tform, coll_line, radius, dst, y_tform * dst_tform,
coll_it->method,&coll ) ){ coll_it->method, &coll)) {
coll_obj=dst; coll_obj = dst;
coll_info=coll_it; coll_info = coll_it;
} }
} }
} }
} }
if( !coll_obj ) break; if (!coll_obj) break;
//register collision //register collision
if( ++hits==MAX_HITS ){ if (++hits == WORLD_COLLISION_HITS) {
// exit(0); // exit(0);
break; break;
} }
collided( src,coll_obj,coll_line,coll,inv_y_scale ); collided(src, coll_obj, coll_line, coll, inv_y_scale);
Plane coll_plane( coll_line*coll.time,coll.normal ); Plane coll_plane(coll_line*coll.time, coll.normal);
coll_plane.d-=COLLISION_FLT_EPSILON; coll_plane.d -= COLLISION_FLT_EPSILON;
coll.time=coll_plane.t_intersect( coll_line ); coll.time = coll_plane.t_intersect(coll_line);
if( coll.time>0 ){// && fabs(coll.normal.dot( coll_line.d ))>FLT_EPSILON ){ if (coll.time > 0) {// && fabs(coll.normal.dot( coll_line.d ))>FLT_EPSILON ){
//update source position - ONLY IF AHEAD! //update source position - ONLY IF AHEAD!
sv=coll_line*coll.time; sv = coll_line*coll.time;
td*=1-coll.time; td *= 1 - coll.time;
td_xz*=1-coll.time; td_xz *= 1 - coll.time;
} }
if( coll_info->response==COLLISION_RESPONSE_STOP ){ if (coll_info->response == COLLISION_RESPONSE_STOP) {
dv=sv; dv = sv;
break; break;
} }
//find nearest point on plane to dest //find nearest point on plane to dest
Vector nv=coll_plane.nearest( dv ); Vector nv = coll_plane.nearest(dv);
if( n_hit==0 ){ if (n_hit == 0) {
dv=nv; dv = nv;
}else if( n_hit==1 ){ } else if (n_hit == 1) {
if( planes[0].distance(nv)>=0 ){ if (planes[0].distance(nv) >= 0) {
dv=nv;n_hit=0; dv = nv; n_hit = 0;
}else if( fabs( planes[0].n.dot( coll_plane.n ) )<1-FLT_EPSILON ){ } else if (fabs(planes[0].n.dot(coll_plane.n)) < 1 - FLT_EPSILON) {
dv=coll_plane.intersect( planes[0] ).nearest( dv ); dv = coll_plane.intersect(planes[0]).nearest(dv);
}else{ } else {
//SQUISHED! //SQUISHED!
//exit(0); //exit(0);
hits=MAX_HITS;break; hits = WORLD_COLLISION_HITS; break;
} }
}else if( planes[0].distance(nv)>=0 && planes[1].distance(nv)>=0 ){ } else if (planes[0].distance(nv) >= 0 && planes[1].distance(nv) >= 0) {
dv=nv;n_hit=0; dv = nv; n_hit = 0;
}else{ } else {
dv=sv;break; dv = sv; break;
} }
Vector dd( dv-sv ); Vector dd(dv - sv);
//going behind initial direction? really necessary? //going behind initial direction? really necessary?
if( dd.dot( dir )<=0 ){ dv=sv;break; } if (dd.dot(dir) <= 0) { dv = sv; break; }
if( coll_info->response==COLLISION_RESPONSE_SLIDE ){ if (coll_info->response == COLLISION_RESPONSE_SLIDE) {
float d=dd.length(); float d = dd.length();
if( d<= FLT_EPSILON ){ dv=sv;break; } if (d <= FLT_EPSILON) { dv = sv; break; }
if( d>td ) dd*=td/d; if (d > td) dd *= td / d;
}else if( coll_info->response==COLLISION_RESPONSE_SLIDEXZ ){ } else if (coll_info->response == COLLISION_RESPONSE_SLIDEXZ) {
float d=Vector( dd.x,0,dd.z ).length(); float d = Vector(dd.x, 0, dd.z).length();
if( d<= FLT_EPSILON ){ dv=sv;break; } if (d <= FLT_EPSILON) { dv = sv; break; }
if( d>td_xz ) dd*=td_xz/d; if (d > td_xz) dd *= td_xz / d;
} }
coll_line.o=sv; coll_line.o = sv;
coll_line.d=dd;dv=sv+dd; coll_line.d = dd; dv = sv + dd;
planes[n_hit++]=coll_plane; planes[n_hit++] = coll_plane;
} }
if( hits ){ if (hits) {
if( hits<MAX_HITS ){ if (hits < WORLD_COLLISION_HITS) {
dv.y*=inv_y_scale; dv.y *= inv_y_scale;
src->setWorldPosition( dv ); src->SetWorldPosition(dv);
}else{ } else {
src->setWorldPosition( panic ); src->SetWorldPosition(panic);
} }
} }
} }
@@ -354,7 +338,7 @@ void World::collide( Object *src ){
for( coll_it=collinfos.begin();coll_it!=collinfos.end();++coll_it ){ for( coll_it=collinfos.begin();coll_it!=collinfos.end();++coll_it ){
vector<Object*>::const_iterator dst_it; vector<Object*>::const_iterator dst_it;
const vector<Object*> &dst_objs=_objsByType[coll_it->dst_type]; const vector<Object*> &dst_objs=_objsByType[coll_it->dst_type];
for( dst_it=dst_objs.begin();dst_it!=dst_objs.end();++dst_it ){ for( dst_it=dst_objs.begin();dst_it!=dst_objs.end();++dst_it ){
@@ -367,7 +351,7 @@ void World::collide( Object *src ){
if( y_scale==1 ){ if( y_scale==1 ){
if( hitTest( if( hitTest(
coll_line,radius,dst,dst_tform, coll_line,radius,dst,dst_tform,
coll_it->method,&coll ) ){ coll_it->method,&coll ) ){
coll_obj=dst; coll_obj=dst;
@@ -375,7 +359,7 @@ void World::collide( Object *src ){
} }
}else{ }else{
if( hitTest( if( hitTest(
coll_line,radius,dst,y_tform * dst_tform, coll_line,radius,dst,y_tform * dst_tform,
coll_it->method,&coll ) ){ coll_it->method,&coll ) ){
coll_obj=dst; coll_obj=dst;
@@ -409,7 +393,7 @@ void World::collide( Object *src ){
//STOP? //STOP?
if( coll_info->response==COLLISION_RESPONSE_STOP ){ if( coll_info->response==COLLISION_RESPONSE_STOP ){
dv=sv; dv=sv;
break; break;
} }
//find nearest point on plane to dest //find nearest point on plane to dest
@@ -463,37 +447,29 @@ void World::collide( Object *src ){
} }
*/ */
void World::update( float elapsed ){ void World::update(float elapsed) {
stats3d[0]=0; stats3d[0] = 0;
for( ;used_colls.size();used_colls.pop_back() ){ for (; used_colls.size(); used_colls.pop_back()) {
free_colls.push_back( used_colls.back() ); free_colls.push_back(used_colls.back());
} }
enumEnabled(); StaticEnumerateEnabled();
vector<Object*>::const_iterator it; for (Object* o : s_objectsEnabled) {
for( it=_enabled.begin();it!=_enabled.end();++it ){ if (int n = o->getCollisionType()) {
Object *o=*it; _objsByTypeSwappable[n].push_back(o);
if( int n=o->getCollisionType() ){
_objsByType[n].push_back(o);
} }
}
for( it=_enabled.begin();it!=_enabled.end();++it ){
Object *o=*it;
o->beginUpdate( elapsed );
if( o->getCollisionType() ) collide( o );
o->beginUpdate(elapsed);
if (o->getCollisionType()) collide(o);
o->endUpdate(); o->endUpdate();
} }
for( int k=0;k<1000;++k ){ for (int k = 0; k < WORLD_COLLISION_TYPES; ++k) {
_objsByType[k].clear(); _objsByTypeSwappable[k].swap(_objsByType[k]);
_objsByTypeSwappable[k].clear();
} }
} }
@@ -505,85 +481,81 @@ static vector<gxLight*> _lights;
static vector<Mirror*> _mirrors; static vector<Mirror*> _mirrors;
static vector<Listener*> _listeners; static vector<Listener*> _listeners;
struct OrderComp{ struct OrderComp {
bool operator()( Object *a,Object *b ){ bool operator()(Object *a, Object *b) {
return a->getOrder()<b->getOrder(); return a->getOrder() < b->getOrder();
} }
}; };
struct TransComp{ struct TransComp {
bool operator()( Model *a,Model *b )const{ bool operator()(Model *a, Model *b)const {
return return
cam_tform.v.distance( a->getRenderTform().v )< cam_tform.v.distance(a->getRenderTform().v) <
cam_tform.v.distance( b->getRenderTform().v ); cam_tform.v.distance(b->getRenderTform().v);
} }
}; };
static vector<Model*> ord_mods,unord_mods; static vector<Model*> ord_mods, unord_mods;
static priority_queue<Model*,vector<Model*>,OrderComp> ord_que; static priority_queue<Model*, vector<Model*>, OrderComp> ord_que;
static priority_queue<Camera*,vector<Camera*>,OrderComp> cam_que; static priority_queue<Camera*, vector<Camera*>, OrderComp> cam_que;
static priority_queue<Model*,vector<Model*>,TransComp> transparents; static priority_queue<Model*, vector<Model*>, TransComp> transparents;
void World::capture(){ void World::capture() {
enumVisible(); StaticEnumerateVisible();
vector<Object*>::const_iterator it; for (Object* o : s_objectsVisible) {
for( it=_visible.begin();it!=_visible.end();++it ){ o->capture();
(*it)->capture();
} }
} }
void World::render( float tween ){ void World::render(float tween) {
//set render tweens, and build ordered and unordered model lists... //set render tweens, and build ordered and unordered model lists...
ord_mods.clear(); ord_mods.clear();
unord_mods.clear(); unord_mods.clear();
_visible.clear(); s_objectsVisible.clear();
_lights.clear(); _lights.clear();
_mirrors.clear(); _mirrors.clear();
_listeners.clear(); _listeners.clear();
enumVisible(); StaticEnumerateVisible();
vector<Object*>::const_iterator it; for (Object* o : s_objectsVisible) {
for( it=_visible.begin();it!=_visible.end();++it ){ if (!o->beginRender(tween)) continue;
Object *o=*it;
if( !o->beginRender(tween) ) continue; if (Light *t = o->getLight()) _lights.push_back(t->getGxLight());
else if (Camera *t = o->getCamera()) cam_que.push(t);
if( Light *t=o->getLight() ) _lights.push_back(t->getGxLight()); else if (Mirror *t = o->getMirror()) _mirrors.push_back(t);
else if( Camera *t=o->getCamera() ) cam_que.push(t); else if (Listener *t = o->getListener()) _listeners.push_back(t);
else if( Mirror *t=o->getMirror() ) _mirrors.push_back(t); else if (Model *t = o->getModel()) {
else if( Listener *t=o->getListener() ) _listeners.push_back(t); if (t->getOrder()) ord_que.push(t);
else if( Model *t=o->getModel() ){ else unord_mods.push_back(t);
if( t->getOrder() ) ord_que.push( t );
else unord_mods.push_back( t );
} }
} }
for( ;ord_que.size();ord_que.pop() ) ord_mods.push_back( ord_que.top() ); for (; ord_que.size(); ord_que.pop()) ord_mods.push_back(ord_que.top());
// gx_runtime->debugLog( "RenderWorld" ); // gx_runtime->debugLog( "RenderWorld" );
if( !gx_scene->begin( _lights ) ) return; if (!gx_scene->begin(_lights)) return;
for( ;cam_que.size();cam_que.pop() ){ for (; cam_que.size(); cam_que.pop()) {
Camera *cam=cam_que.top(); Camera *cam = cam_que.top();
if( !cam->beginRenderFrame() ) continue; if (!cam->beginRenderFrame()) continue;
vector<Mirror*>::const_iterator mir_it; vector<Mirror*>::const_iterator mir_it;
for( mir_it=_mirrors.begin();mir_it!=_mirrors.end();++mir_it ){ for (mir_it = _mirrors.begin(); mir_it != _mirrors.end(); ++mir_it) {
render( cam,*mir_it ); render(cam, *mir_it);
} }
render( cam,0 ); render(cam, 0);
} }
gx_scene->end(); gx_scene->end();
@@ -591,87 +563,87 @@ void World::render( float tween ){
// gx_runtime->debugLog( "End RenderWorld" ); // gx_runtime->debugLog( "End RenderWorld" );
vector<Listener*>::const_iterator lis_it; vector<Listener*>::const_iterator lis_it;
for( lis_it=_listeners.begin();lis_it!=_listeners.end();++lis_it ){ for (lis_it = _listeners.begin(); lis_it != _listeners.end(); ++lis_it) {
(*lis_it)->renderListener(); (*lis_it)->renderListener();
} }
} }
void World::render( Camera *cam,Mirror *mirror ){ void World::render(Camera *cam, Mirror *mirror) {
if( mirror ){ if (mirror) {
const Transform &t=mirror->getRenderTform(); const Transform &t = mirror->getRenderTform();
cam_tform=t * Transform( scaleMatrix( 1,-1,1 ) ) * -t * cam->getRenderTform(); cam_tform = t * Transform(scaleMatrix(1, -1, 1)) * -t * cam->getRenderTform();
gx_scene->setFlippedTris( true ); gx_scene->setFlippedTris(true);
}else{ } else {
cam_tform=cam->getRenderTform(); cam_tform = cam->getRenderTform();
gx_scene->setFlippedTris( false ); gx_scene->setFlippedTris(false);
} }
//set camera matrix //set camera matrix
gx_scene->setViewMatrix( (gxScene::Matrix*)&(-cam_tform) ); gx_scene->setViewMatrix((gxScene::Matrix*)&(-cam_tform));
//initialize render context //initialize render context
RenderContext rc( cam_tform,cam->getFrustum(),mirror!=0 ); RenderContext rc(cam_tform, cam->getFrustum(), mirror != 0);
//draw everything in order //draw everything in order
int ord=0; size_t ord = 0;
gx_scene->setZMode( gxScene::ZMODE_DISABLE ); gx_scene->setZMode(gxScene::ZMODE_DISABLE);
while( ord<ord_mods.size() && ord_mods[ord]->getOrder()>0 ){ while (ord < ord_mods.size() && ord_mods[ord]->getOrder()>0) {
Model *mod=ord_mods[ord++]; Model *mod = ord_mods[ord++];
if( !mod->doAutoFade( cam_tform.v ) ) continue; if (!mod->doAutoFade(cam_tform.v)) continue;
render( mod,rc ); render(mod, rc);
flushTransparent(); flushTransparent();
} }
gx_scene->setZMode( gxScene::ZMODE_NORMAL ); gx_scene->setZMode(gxScene::ZMODE_NORMAL);
for( int k=0;k<unord_mods.size();++k ){ for (size_t k = 0; k < unord_mods.size(); ++k) {
Model *mod=unord_mods[k]; Model *mod = unord_mods[k];
if( !mod->doAutoFade( cam_tform.v ) ) continue; if (!mod->doAutoFade(cam_tform.v)) continue;
render( mod,rc ); render(mod, rc);
} }
gx_scene->setZMode( gxScene::ZMODE_CMPONLY ); gx_scene->setZMode(gxScene::ZMODE_CMPONLY);
flushTransparent(); flushTransparent();
gx_scene->setZMode( gxScene::ZMODE_DISABLE ); gx_scene->setZMode(gxScene::ZMODE_DISABLE);
while( ord<ord_mods.size() ){ while (ord < ord_mods.size()) {
Model *mod=ord_mods[ord++]; Model *mod = ord_mods[ord++];
if( !mod->doAutoFade( cam_tform.v ) ) continue; if (!mod->doAutoFade(cam_tform.v)) continue;
render( mod,rc ); render(mod, rc);
flushTransparent(); flushTransparent();
} }
} }
void World::render( Model *mod,const RenderContext &rc ){ void World::render(Model *mod, const RenderContext &rc) {
bool trans=mod->render( rc ); bool trans = mod->render(rc);
if( mod->queueSize( Model::QUEUE_OPAQUE ) ){ if (mod->queueSize(Model::QUEUE_OPAQUE)) {
if( mod->getRenderSpace()==Model::RENDER_SPACE_LOCAL ){ if (mod->getRenderSpace() == Model::RENDER_SPACE_LOCAL) {
gx_scene->setWorldMatrix( (gxScene::Matrix*)&mod->getRenderTform() ); gx_scene->setWorldMatrix((gxScene::Matrix*)&mod->getRenderTform());
}else{ } else {
gx_scene->setWorldMatrix( 0 ); gx_scene->setWorldMatrix(0);
} }
mod->renderQueue( Model::QUEUE_OPAQUE ); mod->renderQueue(Model::QUEUE_OPAQUE);
} }
if( trans || mod->queueSize( Model::QUEUE_TRANSPARENT ) ){ if (trans || mod->queueSize(Model::QUEUE_TRANSPARENT)) {
transparents.push( mod ); transparents.push(mod);
} }
} }
void World::flushTransparent(){ void World::flushTransparent() {
bool local=true; bool local = true;
for( ;transparents.size();transparents.pop() ){ for (; transparents.size(); transparents.pop()) {
Model *mod=transparents.top(); Model *mod = transparents.top();
if( mod->getRenderSpace()==Model::RENDER_SPACE_LOCAL ){ if (mod->getRenderSpace() == Model::RENDER_SPACE_LOCAL) {
gx_scene->setWorldMatrix( (gxScene::Matrix*)&mod->getRenderTform() ); gx_scene->setWorldMatrix((gxScene::Matrix*)&mod->getRenderTform());
local=true; local = true;
}else if( local ){ } else if (local) {
gx_scene->setWorldMatrix( 0 ); gx_scene->setWorldMatrix(0);
local=false; local = false;
} }
mod->renderQueue( Model::QUEUE_TRANSPARENT ); mod->renderQueue(Model::QUEUE_TRANSPARENT);
} }
} }
blitz3d/world.h
+7 -3
View File
@@ -10,6 +10,9 @@
#include "mirror.h" #include "mirror.h"
#include "listener.h" #include "listener.h"
#define WORLD_COLLISION_TYPES 16
#define WORLD_COLLISION_HITS 4
class World{ class World{
public: public:
//collision methods //collision methods
@@ -34,7 +37,7 @@ public:
void capture(); void capture();
void render( float tween ); void render( float tween );
bool checkLOS( Object *src,Object *dest ); bool CheckLineOfSight( Object *src,Object *dest );
bool hitTest( const Line &line,float radius,Object *obj,const Transform &tf,int method,Collision *curr_coll ); bool hitTest( const Line &line,float radius,Object *obj,const Transform &tf,int method,Collision *curr_coll );
Object *traceRay( const Line &line,float radius,ObjCollision *curr_coll ); Object *traceRay( const Line &line,float radius,ObjCollision *curr_coll );
@@ -43,8 +46,9 @@ private:
int dst_type,method,response; int dst_type,method,response;
}; };
vector<CollInfo> _collInfo[1000]; vector<CollInfo> _collInfo[WORLD_COLLISION_TYPES];
vector<Object*> _objsByType[1000]; std::list<Object*> _objsByType[WORLD_COLLISION_TYPES];
std::list<Object*> _objsByTypeSwappable[WORLD_COLLISION_TYPES];
void collide( Object *src ); void collide( Object *src );
void render( Camera *c,Mirror *m ); void render( Camera *c,Mirror *m );
compiler/declnode.cpp
+8 -10
View File
@@ -6,7 +6,7 @@
// Sequence of declarations // // Sequence of declarations //
////////////////////////////// //////////////////////////////
void DeclSeqNode::proto(DeclSeq *d, Environ *e) { void DeclSeqNode::proto(DeclSeq *d, Environ *e) {
for (int k = 0; k < decls.size(); ++k) { for (size_t k = 0; k < decls.size(); ++k) {
try { decls[k]->proto(d, e); } catch (Ex &x) { try { decls[k]->proto(d, e); } catch (Ex &x) {
if (x.pos < 0) x.pos = decls[k]->pos; if (x.pos < 0) x.pos = decls[k]->pos;
if (!x.file.size()) x.file = decls[k]->file; if (!x.file.size()) x.file = decls[k]->file;
@@ -16,7 +16,7 @@ void DeclSeqNode::proto(DeclSeq *d, Environ *e) {
} }
void DeclSeqNode::semant(Environ *e) { void DeclSeqNode::semant(Environ *e) {
for (int k = 0; k < decls.size(); ++k) { for (size_t k = 0; k < decls.size(); ++k) {
try { decls[k]->semant(e); } catch (Ex &x) { try { decls[k]->semant(e); } catch (Ex &x) {
if (x.pos < 0) x.pos = decls[k]->pos; if (x.pos < 0) x.pos = decls[k]->pos;
if (!x.file.size()) x.file = decls[k]->file; if (!x.file.size()) x.file = decls[k]->file;
@@ -26,7 +26,7 @@ void DeclSeqNode::semant(Environ *e) {
} }
void DeclSeqNode::translate(Codegen *g) { void DeclSeqNode::translate(Codegen *g) {
for (int k = 0; k < decls.size(); ++k) { for (size_t k = 0; k < decls.size(); ++k) {
try { decls[k]->translate(g); } catch (Ex &x) { try { decls[k]->translate(g); } catch (Ex &x) {
if (x.pos < 0) x.pos = decls[k]->pos; if (x.pos < 0) x.pos = decls[k]->pos;
if (!x.file.size()) x.file = decls[k]->file; if (!x.file.size()) x.file = decls[k]->file;
@@ -36,7 +36,7 @@ void DeclSeqNode::translate(Codegen *g) {
} }
void DeclSeqNode::transdata(Codegen *g) { void DeclSeqNode::transdata(Codegen *g) {
for (int k = 0; k < decls.size(); ++k) { for (size_t k = 0; k < decls.size(); ++k) {
try { decls[k]->transdata(g); } catch (Ex &x) { try { decls[k]->transdata(g); } catch (Ex &x) {
if (x.pos < 0) x.pos = decls[k]->pos; if (x.pos < 0) x.pos = decls[k]->pos;
if (!x.file.size()) x.file = decls[k]->file; if (!x.file.size()) x.file = decls[k]->file;
@@ -90,8 +90,7 @@ void VarDeclNode::proto(DeclSeq *d, Environ *e) {
if (expr) sem_var = new DeclVarNode(decl); if (expr) sem_var = new DeclVarNode(decl);
} }
void VarDeclNode::semant(Environ *e) { void VarDeclNode::semant(Environ *e) {}
}
void VarDeclNode::translate(Codegen *g) { void VarDeclNode::translate(Codegen *g) {
if (kind & DECL_GLOBAL) { if (kind & DECL_GLOBAL) {
@@ -149,7 +148,7 @@ void FuncDeclNode::translate(Codegen *g) {
//translate statements //translate statements
stmts->translate(g); stmts->translate(g);
for (int k = 0; k < sem_env->labels.size(); ++k) { for (size_t k = 0; k < sem_env->labels.size(); ++k) {
if (sem_env->labels[k]->def < 0) ex("Undefined label", sem_env->labels[k]->ref); if (sem_env->labels[k]->def < 0) ex("Undefined label", sem_env->labels[k]->ref);
} }
@@ -224,8 +223,7 @@ void DataDeclNode::proto(DeclSeq *d, Environ *e) {
if (expr->sem_type == Type::string_type) str_label = genLabel(); if (expr->sem_type == Type::string_type) str_label = genLabel();
} }
void DataDeclNode::semant(Environ *e) { void DataDeclNode::semant(Environ *e) {}
}
void DataDeclNode::translate(Codegen *g) { void DataDeclNode::translate(Codegen *g) {
if (expr->sem_type != Type::string_type) return; if (expr->sem_type != Type::string_type) return;
@@ -275,7 +273,7 @@ void VectorDeclNode::translate(Codegen *g) {
VectorType *v = sem_type->vectorType(); VectorType *v = sem_type->vectorType();
g->i_data(6, v->label); g->i_data(6, v->label);
int sz = 1; int sz = 1;
for (int k = 0; k < v->sizes.size(); ++k) sz *= v->sizes[k]; for (size_t k = 0; k < v->sizes.size(); ++k) sz *= v->sizes[k];
g->i_data(sz); g->i_data(sz);
string t; string t;
Type *type = v->elementType; Type *type = v->elementType;