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
static const float dtor = 0.0174532925199432957692369076848861f;
static const float s_degreesToRadians = 0.0174532925199432957692369076848861f;
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) {
debugImage(i);
d *= -dtor;
d *= -s_degreesToRadians;
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_R=3399;
static const float dtor=0.0174532925199432957692369076848861f;
static const float rtod=57.2957795130823208767981548141052f;
static const float s_degreesToRadians=0.0174532925199432957692369076848861f;
static const float s_radiansToDegrees=57.2957795130823208767981548141052f;
float bbSin( float n ){ return (float)sin(n*dtor); }
float bbCos( float n ){ return (float)cos(n*dtor); }
float bbTan( float n ){ return (float)tan(n*dtor); }
float bbASin( float n ){ return (float)asin(n)*rtod; }
float bbACos( float n ){ return (float)acos(n)*rtod; }
float bbATan( float n ){ return (float)atan(n)*rtod; }
float bbATan2( float n,float t ){ return (float)atan2(n,t)*rtod; }
float bbSin( float n ){ return (float)sin(n*s_degreesToRadians); }
float bbCos( float n ){ return (float)cos(n*s_degreesToRadians); }
float bbTan( float n ){ return (float)tan(n*s_degreesToRadians); }
float bbASin( float n ){ return (float)asin(n)*s_radiansToDegrees; }
float bbACos( float n ){ return (float)acos(n)*s_radiansToDegrees; }
float bbATan( float n ){ return (float)atan(n)*s_radiansToDegrees; }
float bbATan2( float n,float t ){ return (float)atan2(n,t)*s_radiansToDegrees; }
float bbSqr( float n ){ return (float)sqrt(n); }
float bbFloor( float n ){ return (float)floor(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 ){
_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() );
}
}
@@ -87,13 +87,13 @@ void Animator::updateAnim(){
const Animation &keys=_anims[k].keys[_seq];
if( keys.numPositionKeys() ){
obj->setLocalPosition( keys.getPosition( _time ) );
obj->SetLocalPosition( keys.getPosition( _time ) );
}
if( keys.numScaleKeys() ){
obj->setLocalScale( keys.getScale( _time ) );
obj->SetLocalScale( keys.getScale( _time ) );
}
if( keys.numRotationKeys() ){
obj->setLocalRotation( keys.getRotation( _time ) );
obj->SetLocalRotation( keys.getRotation( _time ) );
}
}
}
@@ -105,9 +105,9 @@ void Animator::updateTrans(){
Object *obj=_objs[k];
const Anim &anim=_anims[k];
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.rot ) obj->setLocalRotation( anim.src_rot.slerpTo( anim.dest_rot,_trans_time ) );
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.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];
if( anim.pos=!!keys.numPositionKeys() ){
anim.src_pos=obj->getLocalPosition();
anim.src_pos=obj->GetLocalPosition();
anim.dest_pos=keys.getPosition( _time );
}
if( anim.scl=!!keys.numScaleKeys() ){
anim.src_scl=obj->getLocalScale();
anim.src_scl=obj->GetLocalScale();
anim.dest_scl=keys.getScale( _time );
}
if( anim.rot=!!keys.numRotationKeys() ){
anim.src_rot=obj->getLocalRotation();
anim.src_rot=obj->GetLocalRotation();
anim.dest_rot=keys.getRotation( _time );
}
}
blitz3d/blitz3d.vcxproj
+79 -6
View File
@@ -9,6 +9,10 @@
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="RelWithDebInfo|Win32">
<Configuration>RelWithDebInfo</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<SccProjectName />
@@ -19,7 +23,7 @@
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v140</PlatformToolset>
<PlatformToolset>v140_xp</PlatformToolset>
<UseOfMfc>false</UseOfMfc>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
@@ -28,6 +32,13 @@
<PlatformToolset>v140</PlatformToolset>
<UseOfMfc>false</UseOfMfc>
<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>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<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="$(VCTargetsPath)Microsoft.Cpp.UpgradeFromVC60.props" />
</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 Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<OutDir>..\#Build\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</OutDir>
<IntDir>..\#Intermediate\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</IntDir>
<LinkIncremental>false</LinkIncremental>
<IncludePath>$(DXSDK_DIR)Include\;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
<LibraryPath>$(DXSDK_DIR)Lib\x86\;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath>
<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 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 Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>..\#Build\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</OutDir>
<IntDir>..\#Intermediate\$(ProjectName)\$(Configuration)-$(PlatformTarget)\</IntDir>
<LinkIncremental>true</LinkIncremental>
<IncludePath>$(DXSDK_DIR)Include\;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
<LibraryPath>$(DXSDK_DIR)Lib\x86\;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath>
<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>
<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>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>false</FunctionLevelLinking>
@@ -127,7 +196,9 @@
<ClCompile Include="listener.cpp" />
<ClCompile Include="loader_3ds.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="md2norms.cpp" />
<ClCompile Include="md2rep.cpp" />
@@ -145,7 +216,9 @@
<ClCompile Include="sprite.cpp" />
<ClCompile Include="std.cpp">
<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)'=='RelWithDebInfo|Win32'">std.h</PrecompiledHeaderFile>
</ClCompile>
<ClCompile Include="surface.cpp" />
<ClCompile Include="terrain.cpp" />
blitz3d/blitz3d.vcxproj.filters
+3 -3
View File
@@ -50,9 +50,6 @@
<ClCompile Include="loader_b3d.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="loader_x.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="md2model.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@@ -116,6 +113,9 @@
<ClCompile Include="world.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="loader_x.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="animation.h">
blitz3d/entity.cpp
+116 -116
View File
@@ -4,194 +4,194 @@
//#include "stats.h"
Entity *Entity::_orphans,*Entity::_last_orphan;
Entity *Entity::_orphans, *Entity::_last_orphan;
enum{
INVALID_LOCALTFORM=1,
INVALID_WORLDTFORM=2
enum {
INVALID_LOCALTFORM = 1,
INVALID_WORLDTFORM = 2
};
void Entity::remove(){
if( _parent ){
if( _parent->_children==this ) _parent->_children=_succ;
if( _parent->_last_child==this ) _parent->_last_child=_pred;
}else{
if( _orphans==this ) _orphans=_succ;
if( _last_orphan==this ) _last_orphan=_pred;
void Entity::RemoveParent() {
if (m_parent) {
if (m_parent->m_children == this) m_parent->m_children = m_listNext;
if (m_parent->m_last_child == this) m_parent->m_last_child = m_listPrev;
} else {
if (_orphans == this) _orphans = m_listNext;
if (_last_orphan == this) _last_orphan = m_listPrev;
}
if( _succ ) _succ->_pred=_pred;
if( _pred ) _pred->_succ=_succ;
if (m_listNext) m_listNext->m_listPrev = m_listPrev;
if (m_listPrev) m_listPrev->m_listNext = m_listNext;
}
void Entity::insert(){
_succ=0;
if( _parent ){
if( _pred=_parent->_last_child ) _pred->_succ=this;
else _parent->_children=this;
_parent->_last_child=this;
}else{
if( _pred=_last_orphan ) _pred->_succ=this;
else _orphans=this;
_last_orphan=this;
void Entity::InsertChildToParent() {
m_listNext = 0;
if (m_parent) {
if (m_listPrev = m_parent->m_last_child) m_listPrev->m_listNext = this;
else m_parent->m_children = this;
m_parent->m_last_child = this;
} else {
if (m_listPrev = _last_orphan) m_listPrev->m_listNext = this;
else _orphans = this;
_last_orphan = this;
}
}
Entity::Entity():
_succ(0),_pred(0),_parent(0),_children(0),_last_child(0),
_visible(true),_enabled(true),
local_scl(1,1,1),
invalid(0){
insert();
Entity::Entity() :
m_listNext(0), m_listPrev(0), m_parent(0), m_children(0), m_last_child(0),
m_isVisible(true), m_isEnabled(true),
m_localScale(1, 1, 1),
invalid(0) {
InsertChildToParent();
}
Entity::Entity( const Entity &e ):
_succ(0),_pred(0),_parent(0),_children(0),_last_child(0),
_name(e._name),_visible(e._visible),_enabled(e._enabled),
local_pos(e.local_pos),
local_scl(e.local_scl),
local_rot(e.local_rot),
invalid( INVALID_LOCALTFORM|INVALID_WORLDTFORM ){
insert();
Entity::Entity(const Entity &e) :
m_listNext(0), m_listPrev(0), m_parent(0), m_children(0), m_last_child(0),
m_name(e.m_name), m_isVisible(e.m_isVisible), m_isEnabled(e.m_isEnabled),
m_localPosition(e.m_localPosition),
m_localScale(e.m_localScale),
m_localRotation(e.m_localRotation),
invalid(INVALID_LOCALTFORM | INVALID_WORLDTFORM) {
InsertChildToParent();
}
Entity::~Entity(){
while( children() ) delete children();
remove();
Entity::~Entity() {
while (GetChildren()) delete GetChildren();
RemoveParent();
}
void Entity::invalidateWorld(){
if( invalid & INVALID_WORLDTFORM ) return;
invalid|=INVALID_WORLDTFORM;
for( Entity *e=_children;e;e=e->_succ ){
e->invalidateWorld();
void Entity::InvalidateWorldTransform() {
if (invalid & INVALID_WORLDTFORM) return;
invalid |= INVALID_WORLDTFORM;
for (Entity *e = m_children; e; e = e->m_listNext) {
e->InvalidateWorldTransform();
}
}
void Entity::invalidateLocal(){
invalid|=INVALID_LOCALTFORM;
invalidateWorld();
void Entity::invalidateLocal() {
invalid |= INVALID_LOCALTFORM;
InvalidateWorldTransform();
}
const Transform &Entity::getLocalTform()const{
if( invalid&INVALID_LOCALTFORM ){
local_tform.m=Matrix( local_rot );
local_tform.m.i*=local_scl.x;
local_tform.m.j*=local_scl.y;
local_tform.m.k*=local_scl.z;
local_tform.v=local_pos;
invalid&=~INVALID_LOCALTFORM;
const Transform &Entity::GetLocalTransform()const {
if (invalid&INVALID_LOCALTFORM) {
m_localTransform.m = Matrix(m_localRotation);
m_localTransform.m.i *= m_localScale.x;
m_localTransform.m.j *= m_localScale.y;
m_localTransform.m.k *= m_localScale.z;
m_localTransform.v = m_localPosition;
invalid &= ~INVALID_LOCALTFORM;
}
return local_tform;
return m_localTransform;
}
const Transform &Entity::getWorldTform()const{
if( invalid&INVALID_WORLDTFORM ){
world_tform=_parent ? _parent->getWorldTform() * getLocalTform() : getLocalTform();
invalid&=~INVALID_WORLDTFORM;
const Transform &Entity::GetWorldTransform()const {
if (invalid&INVALID_WORLDTFORM) {
m_worldTransform = m_parent ? m_parent->GetWorldTransform() * GetLocalTransform() : GetLocalTransform();
invalid &= ~INVALID_WORLDTFORM;
}
return world_tform;
return m_worldTransform;
}
void Entity::setParent( Entity *p ){
if( _parent==p ) return;
void Entity::SetParent(Entity *p) {
if (m_parent == p) return;
remove();
RemoveParent();
_parent=p;
m_parent = p;
insert();
InsertChildToParent();
invalidateWorld();
InvalidateWorldTransform();
}
void Entity::setName( const string &t ){
_name=t;
void Entity::SetName(const string &t) {
m_name = t;
}
void Entity::setVisible( bool visible ){
_visible=visible;
void Entity::SetVisible(bool visible) {
m_isVisible = visible;
}
void Entity::setEnabled( bool enabled ){
_enabled=enabled;
void Entity::SetEnabled(bool enabled) {
m_isEnabled = enabled;
}
void Entity::enumVisible( vector<Object*> &out ){
if( !_visible ) return;
if( Object *o=getObject() ) out.push_back(o);
for( Entity *e=_children;e;e=e->_succ ){
e->enumVisible( out );
void Entity::EnumerateVisible(std::list<Object*> &out) {
if (!m_isVisible) return;
if (Object *o = getObject()) out.push_back(o);
for (Entity *e = m_children; e; e = e->m_listNext) {
e->EnumerateVisible(out);
}
}
void Entity::enumEnabled( vector<Object*> &out ){
if( !_enabled ) return;
if( Object *o=getObject() ) out.push_back(o);
for( Entity *e=_children;e;e=e->_succ ){
e->enumEnabled( out );
void Entity::EnumerateEnabled(std::list<Object*> &out) {
if (!m_isEnabled) return;
if (Object *o = getObject()) out.push_back(o);
for (Entity *e = m_children; e; e = e->m_listNext) {
e->EnumerateEnabled(out);
}
}
void Entity::setLocalPosition( const Vector &v ){
local_pos=v;
void Entity::SetLocalPosition(const Vector &v) {
m_localPosition = v;
invalidateLocal();
}
void Entity::setLocalScale( const Vector &v ){
local_scl=v;
void Entity::SetLocalScale(const Vector &v) {
m_localScale = v;
invalidateLocal();
}
void Entity::setLocalRotation( const Quat &q ){
local_rot=q.normalized();
void Entity::SetLocalRotation(const Quat &q) {
m_localRotation = q.normalized();
invalidateLocal();
}
void Entity::setLocalTform( const Transform &t ){
local_pos=t.v;
local_scl=Vector( t.m.i.length(),t.m.j.length(),t.m.k.length() );
local_rot=matrixQuat( t.m );
void Entity::SetLocalTransform(const Transform &t) {
m_localPosition = t.v;
m_localScale = Vector(t.m.i.length(), t.m.j.length(), t.m.k.length());
m_localRotation = matrixQuat(t.m);
invalidateLocal();
}
void Entity::setWorldPosition( const Vector &v ){
setLocalPosition( _parent ? -_parent->getWorldTform() * v : v );
void Entity::SetWorldPosition(const Vector &v) {
SetLocalPosition(m_parent ? -m_parent->GetWorldTransform() * v : v);
}
void Entity::setWorldScale( const Vector &v ){
setLocalScale( _parent ? v/_parent->getWorldScale() : v );
void Entity::SetWorldScale(const Vector &v) {
SetLocalScale(m_parent ? v / m_parent->GetWorldScale() : v);
}
void Entity::setWorldRotation( const Quat &q ){
setLocalRotation( _parent ? -_parent->getWorldRotation() * q : q );
void Entity::SetWorldRotation(const Quat &q) {
SetLocalRotation(m_parent ? -m_parent->GetWorldRotation() * q : q);
}
void Entity::setWorldTform( const Transform &t ){
setLocalTform( _parent ? -_parent->getWorldTform() * t : t );
void Entity::SetWorldTransform(const Transform &t) {
SetLocalTransform(m_parent ? -m_parent->GetWorldTransform() * t : t);
}
const Vector &Entity::getLocalPosition()const{
return local_pos;
const Vector &Entity::GetLocalPosition()const {
return m_localPosition;
}
const Vector &Entity::getLocalScale()const{
return local_scl;
const Vector &Entity::GetLocalScale()const {
return m_localScale;
}
const Quat &Entity::getLocalRotation()const{
return local_rot;
const Quat &Entity::GetLocalRotation()const {
return m_localRotation;
}
const Vector &Entity::getWorldPosition()const{
return getWorldTform().v;
const Vector &Entity::GetWorldPosition()const {
return GetWorldTransform().v;
}
const Vector &Entity::getWorldScale()const{
world_scl=_parent ? _parent->getWorldScale() * local_scl : local_scl;
return world_scl;
const Vector &Entity::GetWorldScale()const {
m_worldScale = m_parent ? m_parent->GetWorldScale() * m_localScale : m_localScale;
return m_worldScale;
}
const Quat &Entity::getWorldRotation()const{
world_rot=_parent ? _parent->getWorldRotation() * local_rot : local_rot;
return world_rot;
const Quat &Entity::GetWorldRotation()const {
m_worldRotation = m_parent ? m_parent->GetWorldRotation() * m_localRotation : m_localRotation;
return m_worldRotation;
}
blitz3d/entity.h
+53 -55
View File
@@ -16,86 +16,84 @@ class Listener;
class MeshModel;
class MD2Model;
class Entity{
public:
class Entity {
public:
Entity();
Entity( const Entity &e );
Entity(const Entity &e);
virtual ~Entity();
virtual Entity *clone()=0;
virtual Entity *clone() = 0;
//ugly casts!
virtual Object *getObject(){ return 0; }
virtual Camera *getCamera(){ return 0; }
virtual Light *getLight(){ return 0; }
virtual Model *getModel(){ return 0; }
virtual Mirror *getMirror(){ return 0; }
virtual Listener *getListener(){ return 0; }
virtual Object *getObject() { return nullptr; }
virtual Camera *getCamera() { return nullptr; }
virtual Light *getLight() { return nullptr; }
virtual Model *getModel() { return nullptr; }
virtual Mirror *getMirror() { return nullptr; }
virtual Listener *getListener() { return nullptr; }
void setName( const std::string &t );
void setParent( Entity *parent );
void SetName(const std::string &t);
std::string getName()const { return m_name; }
void setVisible( bool vis );
void setEnabled( bool ena );
void SetParent(Entity *parent);
Entity *getParent()const { return m_parent; }
bool visible()const{ return _visible; }
bool enabled()const{ return _enabled; }
void SetVisible(bool vis);
bool IsVisible()const { return m_isVisible; }
void EnumerateVisible(std::list<Object*> &out);
void enumVisible( vector<Object*> &out );
void enumEnabled( vector<Object*> &out );
void SetEnabled(bool ena);
bool IsEnabled()const { return m_isEnabled; }
void EnumerateEnabled(std::list<Object*> &out);
Entity *children()const{ return _children; }
Entity *successor()const{ return _succ; }
void SetLocalPosition(const Vector &v);
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; }
Entity *getParent()const{ return _parent; }
void SetWorldPosition(const Vector &v);
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 );
void setLocalScale( const Vector & v );
void setLocalRotation( const Quat &q );
void setLocalTform( const Transform &t );
Entity* GetChildren()const { return m_children; }
Entity* GetSuccessor()const { return m_listNext; }
void setWorldPosition( const Vector &v );
void setWorldScale( const Vector &v );
void setWorldRotation( const Quat &q );
void setWorldTform( const Transform &t );
const Vector &getLocalPosition()const;
const Vector &getLocalScale()const;
const Quat &getLocalRotation()const;
const Transform &getLocalTform()const;
static Entity* GetEntityOrphans() { return _orphans; }
const Vector &getWorldPosition()const;
const Vector &getWorldScale()const;
const Quat &getWorldRotation()const;
const Transform &getWorldTform()const;
private:
Entity *m_listNext, *m_listPrev, *m_parent, *m_children, *m_last_child;
static Entity *orphans(){ return _orphans; }
static Entity *_orphans, *_last_orphan;
private:
Entity *_succ,*_pred,*_parent,*_children,*_last_child;
bool m_isVisible, m_isEnabled;
static Entity *_orphans,*_last_orphan;
bool _visible,_enabled;
std::string _name;
std::string m_name;
mutable int invalid;
Quat local_rot;
Vector local_pos,local_scl;
mutable Transform local_tform;
Quat m_localRotation;
Vector m_localPosition, m_localScale;
mutable Transform m_localTransform;
mutable Quat world_rot;
mutable Vector world_pos,world_scl;
mutable Transform world_tform;
mutable Quat m_worldRotation;
mutable Vector m_worldPosition, m_worldScale;
mutable Transform m_worldTransform;
void insert();
void remove();
void InsertChildToParent();
void RemoveParent();
void invalidateLocal();
void invalidateWorld();
void InvalidateWorldTransform();
};
#endif
blitz3d/listener.cpp
+3 -3
View File
@@ -25,10 +25,10 @@ Listener::~Listener(){
void Listener::renderListener(){
if( !gx_audio ) return;
const Vector &pos=getWorldTform().v;
const Vector &pos=GetWorldTransform().v;
const Vector &vel=getVelocity();
const Vector &forward=getWorldTform().m.k.normalized();
const Vector &up=getWorldTform().m.j.normalized();
const Vector &forward=GetWorldTransform().m.k.normalized();
const Vector &up=GetWorldTransform().m.j.normalized();
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;
mesh->setWorldTform( tform );
mesh->SetWorldTransform( tform );
if( animonly ){
MeshLoader::endMesh( 0 );
@@ -245,8 +245,8 @@ static void parseObject( MeshModel *root ){
switch( id ){
case CHUNK_TRIMESH:
mesh=new MeshModel();
mesh->setName( name );
mesh->setParent( root );
mesh->SetName( name );
mesh->SetParent( root );
name_map[name]=mesh;
parseTriMesh( mesh );
break;
@@ -420,8 +420,8 @@ static void parseMeshInfo( MeshModel *root,float curr_time ){
MeshModel *mesh=0;
if( name=="$$$DUMMY" ){
mesh=new MeshModel();
mesh->setName( inst );
mesh->setParent( p );
mesh->SetName( inst );
mesh->SetParent( p );
}else{
map<string,MeshModel*>::const_iterator it=name_map.find( name );
if( it==name_map.end() ) return;
@@ -431,9 +431,9 @@ static void parseMeshInfo( MeshModel *root,float curr_time ){
mesh->transform( -pivot );
}
Transform t=
mesh->getWorldTform();
mesh->setParent( p );
mesh->setWorldTform( t );
mesh->GetWorldTransform();
mesh->SetParent( p );
mesh->SetWorldTransform( t );
}
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();
obj->setName( name );
obj->setLocalPosition( Vector( pos[0],pos[1],pos[2] ) );
obj->setLocalScale( Vector( scl[0],scl[1],scl[2] ) );
obj->setLocalRotation( Quat( rot[0],Vector( rot[1],rot[2],rot[3] ) ) );
obj->SetName( name );
obj->SetLocalPosition( Vector( pos[0],pos[1],pos[2] ) );
obj->SetLocalScale( Vector( scl[0],scl[1],scl[2] ) );
obj->SetLocalRotation( Quat( rot[0],Vector( rot[1],rot[2],rot[3] ) ) );
obj->setAnimation( keys );
if( mesh ){
@@ -310,7 +310,7 @@ static Object *readObject( Object *parent ){
obj->setAnimator( new Animator( obj,anim_len ) );
}
if( parent ) obj->setParent( parent );
if( parent ) obj->SetParent( parent );
return obj;
}
blitz3d/loader_x.cpp
+12 -8
View File
@@ -5,7 +5,11 @@
#include "animation.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 <rmxftmpl.h>
@@ -17,7 +21,7 @@ static bool conv,flip_tris;
static Transform conv_tform;
static bool collapse,animonly;
static void parseAnimKey( IDirectXFileData *fileData,MeshModel *e ){
static void parseAnimKey(ID3DXFileData *fileData, MeshModel *e) {
DWORD sz;int *data;
if( fileData->GetData( 0,&sz,(void**)&data )<0 ) return;
@@ -66,7 +70,7 @@ static void parseAnimKey( IDirectXFileData *fileData,MeshModel *e ){
e->setAnimation( anim );
}
static void parseAnim( IDirectXFileData *fileData ){
static void parseAnim(ID3DXFileData *fileData) {
const GUID *guid;
IDirectXFileObject *childObj;
IDirectXFileData *childData;
@@ -270,7 +274,7 @@ static void parseMesh( IDirectXFileData *fileData,MeshModel *mesh ){
}
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];
int *data=f.data;
int cnt=*data++;if( cnt<3 ) continue;
@@ -299,7 +303,7 @@ static MeshModel *parseFrame( IDirectXFileData *fileData ){
char name[80];DWORD len=80;
if( fileData->GetName( name,&len )<0 ) return e;
e->setName( name );
e->SetName( name );
frames_map[name]=e;
//iterate through child objects...
@@ -315,13 +319,13 @@ static MeshModel *parseFrame( IDirectXFileData *fileData ){
Vector( data->_31,data->_32,data->_33 ) ),
Vector( data->_41,data->_42,data->_43 ) );
if( conv ) tform=conv_tform * tform * -conv_tform;
e->setLocalTform( tform );
e->SetLocalTransform( tform );
}
}else if( *guid==TID_D3DRMMesh ){
if( !animonly ) parseMesh( childData,e );
}else if( *guid==TID_D3DRMFrame ){
MeshModel *t=parseFrame( childData );
t->setParent( e );
t->SetParent( e );
}
}
childData->Release();
@@ -354,7 +358,7 @@ static MeshModel *parseFile( const string &file ){
if( !animonly) parseMesh( fileData,e );
}else if( *guid==TID_D3DRMFrame ){
MeshModel *t=parseFrame( fileData );
t->setParent( e );
t->SetParent( e );
}else if( *guid==TID_D3DRMAnimationSet ){
if( !collapse ) parseAnimSet( fileData );
}
blitz3d/meshmodel.cpp
+158 -159
View File
@@ -5,169 +5,168 @@
extern gxGraphics *gx_graphics;
struct MeshModel::Rep : public Surface::Monitor{
struct MeshModel::Rep : public Surface::Monitor {
int ref_cnt;
mutable Box box,cullBox;
mutable Box box, cullBox;
mutable MeshCollider *collider;
mutable int box_valid,coll_valid,norms_valid;
mutable int box_valid, coll_valid, norms_valid;
SurfaceList surfaces;
vector<Transform> bone_tforms;
Rep():
ref_cnt(1),collider(0),box_valid(-1),coll_valid(-1),norms_valid(-1){
geom_changes=brush_changes=0;
Rep() :
ref_cnt(1), collider(0), box_valid(-1), coll_valid(-1), norms_valid(-1) {
geom_changes = brush_changes = 0;
}
~Rep(){
~Rep() {
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 *t=new Surface( this );
surfaces.push_back( t );
t->setBrush( b );
Surface *createSurface(const Brush &b) {
Surface *t = new Surface(this);
surfaces.push_back(t);
t->setBrush(b);
return t;
}
Surface *findSurface( const Brush &b ){
for( int k=0;k<surfaces.size();++k ){
Surface *s=surfaces[k];
if( s->getBrush()<b || b<s->getBrush() ) continue;
Surface *findSurface(const Brush &b) {
for (int k = 0; k < surfaces.size(); ++k) {
Surface *s = surfaces[k];
if (s->getBrush() < b || b < s->getBrush()) continue;
return s;
}
return 0;
}
void paint( const Brush &b ){
for( int k=0;k<surfaces.size();++k ){
Surface *s=surfaces[k];
s->setBrush( b );
void paint(const Brush &b) {
for (int k = 0; k < surfaces.size(); ++k) {
Surface *s = surfaces[k];
s->setBrush(b);
}
}
void add( Rep *t ){
if( cullBox.empty() && !t->cullBox.empty() ){
setCullBox( t->cullBox );
void add(Rep *t) {
if (cullBox.empty() && !t->cullBox.empty()) {
setCullBox(t->cullBox);
}
for( int k=0;k<t->surfaces.size();++k ){
Surface *src=t->surfaces[k];
Surface *dest=findSurface( src->getBrush() );
if( !dest ) dest=createSurface( src->getBrush() );
for (int k = 0; k < t->surfaces.size(); ++k) {
Surface *src = t->surfaces[k];
Surface *dest = findSurface(src->getBrush());
if (!dest) dest = createSurface(src->getBrush());
int j;
for( j=0;j<src->numTriangles();++j ){
Surface::Triangle t=src->getTriangle( j );
t.verts[0]+=dest->numVertices();
t.verts[1]+=dest->numVertices();
t.verts[2]+=dest->numVertices();
dest->addTriangle( t );
for (j = 0; j < src->numTriangles(); ++j) {
Surface::Triangle t = src->getTriangle(j);
t.verts[0] += dest->numVertices();
t.verts[1] += dest->numVertices();
t.verts[2] += dest->numVertices();
dest->addTriangle(t);
}
for( j=0;j<src->numVertices();++j ){
dest->addVertex( src->getVertex( j ) );
for (j = 0; j < src->numVertices(); ++j) {
dest->addVertex(src->getVertex(j));
}
}
}
void transform( const Transform &t ){
Matrix co=t.m.cofactor();
for( int k=0;k<surfaces.size();++k ){
Surface *s=surfaces[k];
for( int j=0;j<s->numVertices();++j ){
const Vector &v=s->getVertex(j).coords;
const Vector &n=s->getVertex(j).normal;
s->setCoords( j,t*v );
s->setNormal( j,co*n );
void transform(const Transform &t) {
Matrix co = t.m.cofactor();
for (int k = 0; k < surfaces.size(); ++k) {
Surface *s = surfaces[k];
for (int j = 0; j < s->numVertices(); ++j) {
const Vector &v = s->getVertex(j).coords;
const Vector &n = s->getVertex(j).normal;
s->setCoords(j, t*v);
s->setNormal(j, co*n);
}
}
}
void flip(){
for( int k=0;k<surfaces.size();++k ){
Surface *s=surfaces[k];
void flip() {
for (int k = 0; k < surfaces.size(); ++k) {
Surface *s = surfaces[k];
int j;
for( j=0;j<s->numVertices();++j ){
s->setNormal( j,-s->getVertex(j).normal );
for (j = 0; j < s->numVertices(); ++j) {
s->setNormal(j, -s->getVertex(j).normal);
}
for( j=0;j<s->numTriangles();++j ){
Surface::Triangle t=s->getTriangle(j);
std::swap( t.verts[1],t.verts[2] );
s->setTriangle( j,t );
for (j = 0; j < s->numTriangles(); ++j) {
Surface::Triangle t = s->getTriangle(j);
std::swap(t.verts[1], t.verts[2]);
s->setTriangle(j, t);
}
}
}
void setCullBox( const Box &t ){
cullBox=t;
void setCullBox(const Box &t) {
cullBox = t;
}
void updateNormals(){
if( norms_valid!=geom_changes ){
for( int k=0;k<surfaces.size();++k ){
Surface *s=surfaces[k];
void updateNormals() {
if (norms_valid != geom_changes) {
for (int k = 0; k < surfaces.size(); ++k) {
Surface *s = surfaces[k];
s->updateNormals();
}
norms_valid=geom_changes;
norms_valid = geom_changes;
}
}
const Box &getBox()const{
if( box_valid!=geom_changes ){
const Box &getBox()const {
if (box_valid != geom_changes) {
box.clear();
for( int k=0;k<surfaces.size();++k ){
Surface *s=surfaces[k];
for( int j=0;j<s->numVertices();++j ){
box.update( s->getVertex(j).coords );
for (int k = 0; k < surfaces.size(); ++k) {
Surface *s = surfaces[k];
for (int j = 0; j < s->numVertices(); ++j) {
box.update(s->getVertex(j).coords);
}
}
box_valid=geom_changes;
box_valid = geom_changes;
}
return box;
}
const Box &getCullBox()const{
const Box &getCullBox()const {
return cullBox.empty() ? getBox() : cullBox;
}
MeshCollider *getCollider()const{
if( coll_valid!=geom_changes ){
MeshCollider *getCollider()const {
if (coll_valid != geom_changes) {
delete collider;
vector<MeshCollider::Vertex> verts;
vector<MeshCollider::Triangle> tris;
for( int k=0;k<surfaces.size();++k ){
Surface *s=surfaces[k];
for (int k = 0; k < surfaces.size(); ++k) {
Surface *s = surfaces[k];
int j;
for( j=0;j<s->numTriangles();++j ){
for (j = 0; j < s->numTriangles(); ++j) {
MeshCollider::Triangle q;
q.verts[0]=s->getTriangle(j).verts[0]+verts.size();
q.verts[1]=s->getTriangle(j).verts[1]+verts.size();
q.verts[2]=s->getTriangle(j).verts[2]+verts.size();
q.surface=s;
q.index=j;
tris.push_back( q );
q.verts[0] = s->getTriangle(j).verts[0] + verts.size();
q.verts[1] = s->getTriangle(j).verts[1] + verts.size();
q.verts[2] = s->getTriangle(j).verts[2] + verts.size();
q.surface = s;
q.index = j;
tris.push_back(q);
}
for( j=0;j<s->numVertices();++j ){
for (j = 0; j < s->numVertices(); ++j) {
MeshCollider::Vertex q;
q.coords=s->getVertex(j).coords;
verts.push_back( q );
q.coords = s->getVertex(j).coords;
verts.push_back(q);
}
}
collider=new MeshCollider( verts,tris );
coll_valid=geom_changes;
collider = new MeshCollider(verts, tris);
coll_valid = geom_changes;
}
return collider;
}
};
MeshModel::MeshModel():
rep( new Rep() ),brush_changes(0){
}
MeshModel::MeshModel() :
rep(new Rep()), brush_changes(0) {}
MeshModel::MeshModel( const MeshModel &t ):Model( t ),
rep( t.rep ),brush_changes( rep->brush_changes-1 ){
MeshModel::MeshModel(const MeshModel &t) : Model(t),
rep(t.rep), brush_changes(rep->brush_changes - 1) {
++rep->ref_cnt;
surf_bones.resize( t.surf_bones.size() );
surf_bones.resize(t.surf_bones.size());
/*
if( 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(){
if( !--rep->ref_cnt ) delete rep;
MeshModel::~MeshModel() {
if (!--rep->ref_cnt) delete rep;
}
void MeshModel::updateNormals(){
void MeshModel::updateNormals() {
rep->updateNormals();
}
void MeshModel::setCullBox( const Box &box ){
rep->setCullBox( box );
void MeshModel::setCullBox(const Box &box) {
rep->setCullBox(box);
}
void MeshModel::setRenderBrush( const Brush &b ){
void MeshModel::setRenderBrush(const Brush &b) {
--brush_changes;
render_brush=b;
render_brush = b;
}
void MeshModel::createBones(){
setRenderSpace( RENDER_SPACE_WORLD );
const vector<Object*> &bones=getAnimator()->getObjects();
void MeshModel::createBones() {
setRenderSpace(RENDER_SPACE_WORLD);
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 ){
rep->bone_tforms[k]=-bones[k]->getWorldTform();
for (int k = 0; k < bones.size(); ++k) {
rep->bone_tforms[k] = -bones[k]->GetWorldTransform();
}
}
bool MeshModel::render( const RenderContext &rc ){
bool MeshModel::render(const RenderContext &rc) {
const Box &b=rep->getCullBox();
if( b.empty() ) return false;
const Box &b = rep->getCullBox();
if (b.empty()) return false;
static Frustum model_frustum;
new( &model_frustum ) Frustum( rc.getWorldFrustum(),-getRenderTform() );
if( !model_frustum.cull( b ) ) return false;
new(&model_frustum) Frustum(rc.getWorldFrustum(), -getRenderTform());
if (!model_frustum.cull(b)) return false;
if( brush_changes!=rep->brush_changes ){
if (brush_changes != rep->brush_changes) {
brushes.clear();
for( int k=0;k<rep->surfaces.size();++k ){
Surface *s=rep->surfaces[k];
brushes.push_back( Brush( s->getBrush(),render_brush ) );
for (int k = 0; k < rep->surfaces.size(); ++k) {
Surface *s = rep->surfaces[k];
brushes.push_back(Brush(s->getBrush(), render_brush));
}
brush_changes=rep->brush_changes;
brush_changes = rep->brush_changes;
}
if( !surf_bones.size() ){
for( int k=0;k<rep->surfaces.size();++k ){
Surface *s=rep->surfaces[k];
if( gxMesh *mesh=s->getMesh() ){
enqueue( mesh,0,s->numVertices(),0,s->numTriangles(),brushes[k] );
if (!surf_bones.size()) {
for (int k = 0; k < rep->surfaces.size(); ++k) {
Surface *s = rep->surfaces[k];
if (gxMesh *mesh = s->getMesh()) {
enqueue(mesh, 0, s->numVertices(), 0, s->numTriangles(), brushes[k]);
}
}
return false;
}
//OK, its boned!
const vector<Object*> &bones=getAnimator()->getObjects();
const vector<Object*> &bones = getAnimator()->getObjects();
int k;
for( k=0;k<bones.size();++k ){
Transform t=
bones[k]->getRenderTform() * rep->bone_tforms[k];
surf_bones[k].coord_tform=t;
surf_bones[k].normal_tform=t.m.cofactor();
for (k = 0; k < bones.size(); ++k) {
Transform t =
bones[k]->getRenderTform() * rep->bone_tforms[k];
surf_bones[k].coord_tform = t;
surf_bones[k].normal_tform = t.m.cofactor();
}
bool trans=false;
for( k=0;k<rep->surfaces.size();++k ){
Surface *s=rep->surfaces[k];
if( brushes[k].getBlend()==gxScene::BLEND_REPLACE ){
if( gxMesh *mesh=s->getMesh( surf_bones ) ){
enqueue( mesh,0,s->numVertices(),0,s->numTriangles(),brushes[k] );
bool trans = false;
for (k = 0; k < rep->surfaces.size(); ++k) {
Surface *s = rep->surfaces[k];
if (brushes[k].getBlend() == gxScene::BLEND_REPLACE) {
if (gxMesh *mesh = s->getMesh(surf_bones)) {
enqueue(mesh, 0, s->numVertices(), 0, s->numTriangles(), brushes[k]);
}
}else{
trans=true;
} else {
trans = true;
}
}
return trans;
}
void MeshModel::renderQueue( int type ){
if( type==QUEUE_TRANSPARENT && surf_bones.size() ){
for( int k=0;k<rep->surfaces.size();++k ){
Surface *s=rep->surfaces[k];
if( brushes[k].getBlend()!=gxScene::BLEND_REPLACE ){
if( gxMesh *mesh=s->getMesh( surf_bones ) ){
enqueue( mesh,0,s->numVertices(),0,s->numTriangles(),brushes[k] );
void MeshModel::renderQueue(int type) {
if (type == QUEUE_TRANSPARENT && surf_bones.size()) {
for (int k = 0; k < rep->surfaces.size(); ++k) {
Surface *s = rep->surfaces[k];
if (brushes[k].getBlend() != gxScene::BLEND_REPLACE) {
if (gxMesh *mesh = s->getMesh(surf_bones)) {
enqueue(mesh, 0, s->numVertices(), 0, s->numTriangles(), brushes[k]);
}
}
}
}
Model::renderQueue( type );
Model::renderQueue(type);
}
Surface *MeshModel::createSurface( const Brush &b ){
return rep->createSurface( b );
Surface *MeshModel::createSurface(const Brush &b) {
return rep->createSurface(b);
--brush_changes;
}
void MeshModel::flipTriangles(){
void MeshModel::flipTriangles() {
rep->flip();
}
void MeshModel::transform( const Transform &t ){
rep->transform( t );
void MeshModel::transform(const Transform &t) {
rep->transform(t);
}
void MeshModel::add( const MeshModel &t ){
rep->add( t.rep );
void MeshModel::add(const MeshModel &t) {
rep->add(t.rep);
}
const MeshModel::SurfaceList &MeshModel::getSurfaces()const{
const MeshModel::SurfaceList &MeshModel::getSurfaces()const {
return rep->surfaces;
}
void MeshModel::paint( const Brush &b ){
rep->paint( b );
void MeshModel::paint(const Brush &b) {
rep->paint(b);
}
const Box &MeshModel::getBox()const{
const Box &MeshModel::getBox()const {
return rep->getBox();
}
MeshCollider *MeshModel::getCollider()const{
MeshCollider *MeshModel::getCollider()const {
return rep->getCollider();
}
Surface *MeshModel::findSurface( const Brush &b )const{
return rep->findSurface( b );
Surface *MeshModel::findSurface(const Brush &b)const {
return rep->findSurface(b);
}
bool MeshModel::collide( const Line &line,float radius,Collision *curr_coll,const Transform &t ){
return getCollider()->collide( line,radius,curr_coll,t );
bool MeshModel::collide(const Line &line, float radius, Collision *curr_coll, const Transform &t) {
return getCollider()->collide(line, radius, curr_coll, t);
}
bool MeshModel::intersects( const MeshModel &m )const{
return getCollider()->intersects( *m.getCollider(),-m.getWorldTform()*getWorldTform() );
bool MeshModel::intersects(const MeshModel &m)const {
return getCollider()->intersects(*m.getCollider(), -m.GetWorldTransform()*GetWorldTransform());
}
blitz3d/object.cpp
+14 -14
View File
@@ -27,9 +27,9 @@ Object::~Object(){
Object *Object::copy(){
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();
cpy->setParent( last_copy );
cpy->SetParent( last_copy );
}
if( animator ) last_copy->setAnimator( new Animator( animator ) );
return last_copy;
@@ -38,7 +38,7 @@ Object *Object::copy(){
void Object::reset(){
colls.clear();
velocity=Vector();
prev_tform=getWorldTform();
prev_tform=GetWorldTransform();
}
void Object::setCollisionType( int type ){
@@ -73,26 +73,26 @@ void Object::addCollision( const ObjCollision *c ){
}
void Object::endUpdate(){
velocity=(getWorldTform().v-prev_tform.v)/elapsed;
prev_tform=getWorldTform();
velocity=(GetWorldTransform().v-prev_tform.v)/elapsed;
prev_tform=GetWorldTransform();
}
void Object::capture(){
capt_pos=getLocalPosition();
capt_scl=getLocalScale();
capt_rot=getLocalRotation();
capt_pos=GetLocalPosition();
capt_scl=GetLocalScale();
capt_rot=GetLocalRotation();
captured=true;
}
bool Object::beginRender( float tween ){
updateSounds();
if( tween==1 || !captured ){
render_tform=getWorldTform();
render_tform=GetWorldTransform();
render_tform_valid=true;
}else{
Vector pos=(getLocalPosition()-capt_pos)*tween+capt_pos;
Vector scl=(getLocalScale()-capt_scl)*tween+capt_scl;
Quat rot=capt_rot.slerpTo( getLocalRotation(),tween );
Vector pos=(GetLocalPosition()-capt_pos)*tween+capt_pos;
Vector scl=(GetLocalScale()-capt_scl)*tween+capt_scl;
Quat rot=capt_rot.slerpTo( GetLocalRotation(),tween );
tween_tform.m=Matrix( rot );
tween_tform.m.i*=scl.x;
tween_tform.m.j*=scl.y;
@@ -143,7 +143,7 @@ const Transform &Object::getPrevWorldTform()const{
gxChannel *Object::emitSound( gxSound *sound ){
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 ){
if( chan==channels[k] ) return chan;
if( !channels[k] ) return channels[k]=chan;
@@ -155,7 +155,7 @@ gxChannel *Object::emitSound( gxSound *sound ){
void Object::updateSounds(){
for( int k=0;k<channels.size();++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;
}
}
blitz3d/terrainrep.cpp
+2 -2
View File
@@ -40,10 +40,10 @@ struct TerrainRep::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;
}
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) {
//check filters...
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) {
flags |= filters[k].flags;
}
blitz3d/world.cpp
+248 -276
View File
@@ -10,19 +10,19 @@ float stats3d[10];
extern gxScene *gx_scene;
extern gxRuntime *gx_runtime;
static vector<Object*> _enabled,_visible;
static std::list<Object*> s_objectsEnabled, s_objectsVisible;
static void enumEnabled(){
_enabled.clear();
for( Entity *e=Entity::orphans();e;e=e->successor() ){
e->enumEnabled( _enabled );
static void StaticEnumerateEnabled() {
s_objectsEnabled.clear();
for (Entity *e = Entity::GetEntityOrphans(); e; e = e->GetSuccessor()) {
e->EnumerateEnabled(s_objectsEnabled);
}
}
static void enumVisible(){
_visible.clear();
for( Entity *e=Entity::orphans();e;e=e->successor() ){
e->enumVisible( _visible );
static void StaticEnumerateVisible() {
s_objectsVisible.clear();
for (Entity *e = Entity::GetEntityOrphans(); e; e = e->GetSuccessor()) {
e->EnumerateVisible(s_objectsVisible);
}
}
@@ -30,113 +30,107 @@ static void enumVisible(){
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;
if( free_colls.size() ){
c=free_colls.back();
if (free_colls.size()) {
c = free_colls.back();
free_colls.pop_back();
}else{
c=new ObjCollision();
} else {
c = new ObjCollision();
}
used_colls.push_back( c );
c->with=with;
c->coords=coords;
c->collision=coll;
used_colls.push_back(c);
c->with = with;
c->coords = coords;
c->collision = coll;
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;
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->coords.y*=y_scale;
src->addCollision( c );
c = allocObjColl(dest, coords, coll);
c->coords.y *= y_scale;
src->addCollision(c);
c=allocObjColl( src,coords,coll );
c->coords.y*=y_scale;
dest->addCollision( c );
c = allocObjColl(src, coords, coll);
c->coords.y *= y_scale;
dest->addCollision(c);
}
void World::clearCollisions(){
for( int k=0;k<1000;++k ){
void World::clearCollisions() {
for (int k = 0; k < 1000; ++k) {
_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];
for( int k=0;k<info.size();++k ){
const CollInfo &t=info[k];
if( dst_type==t.dst_type ) return;
vector<CollInfo> &info = _collInfo[src_type];
for (size_t k = 0; k < info.size(); ++k) {
const CollInfo &t = info[k];
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);
}
bool World::hitTest( const Line &line,float radius,Object *obj,const Transform &tf,int method,Collision *curr_coll ){
switch( method ){
case COLLISION_METHOD_SPHERE:
return curr_coll->sphereCollide( line,radius,tf.v,obj->getCollisionRadii().x );
case COLLISION_METHOD_POLYGON:
return obj->collide( line,radius,curr_coll,tf );
case COLLISION_METHOD_BOX:
Transform t=tf;
t.m.i.normalize();t.m.j.normalize();t.m.k.normalize();
if( curr_coll->boxCollide( ~t*line,radius,obj->getCollisionBox() ) ){
curr_coll->normal=t.m*curr_coll->normal;
return true;
}
bool World::hitTest(const Line &line, float radius, Object *obj, const Transform &tf, int method, Collision *curr_coll) {
switch (method) {
case COLLISION_METHOD_SPHERE:
return curr_coll->sphereCollide(line, radius, tf.v, obj->getCollisionRadii().x);
case COLLISION_METHOD_POLYGON:
return obj->collide(line, radius, curr_coll, tf);
case COLLISION_METHOD_BOX:
Transform t = tf;
t.m.i.normalize(); t.m.j.normalize(); t.m.k.normalize();
if (curr_coll->boxCollide(~t*line, radius, obj->getCollisionBox())) {
curr_coll->normal = t.m*curr_coll->normal;
return true;
}
}
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;
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 ){
Object *obj=*it;
if( obj==src || obj==dest || !obj->getPickGeometry() || !obj->getObscurer() ) continue;
if( hitTest( line,0,obj,obj->getWorldTform(),obj->getPickGeometry(),&curr_coll ) ){
if (hitTest(line, 0, obj, obj->GetWorldTransform(), obj->getPickGeometry(), &curr_coll)) {
return false;
}
}
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( it=_enabled.begin();it!=_enabled.end();++it ){
Object *obj=*it;
for (Object* obj : s_objectsEnabled) {
if( !obj->getPickGeometry() ) continue;
if (!obj->getPickGeometry()) continue;
if( hitTest( line,radius,obj,obj->getWorldTform(),obj->getPickGeometry(),&curr_coll->collision ) ){
coll_obj=obj;
if (hitTest(line, radius, obj, obj->GetWorldTransform(), obj->getPickGeometry(), &curr_coll->collision)) {
coll_obj = obj;
}
}
if( curr_coll->with=coll_obj ){
curr_coll->coords=line*curr_coll->collision.time-curr_coll->collision.normal*radius;
if (curr_coll->with = coll_obj) {
curr_coll->coords = line*curr_coll->collision.time - curr_coll->collision.normal*radius;
}
return coll_obj;
}
@@ -144,158 +138,148 @@ Object *World::traceRay( const Line &line,float radius,ObjCollision *curr_coll )
//
// 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;
Vector dv=src->getWorldTform().v;
Vector sv=src->getPrevWorldTform().v;
if( sv==dv ){
if( dv.x!=sv.x || dv.y!=sv.y || dv.z!=sv.z ){
src->setWorldPosition( sv );
if (sv == dv) {
if (dv.x != sv.x || dv.y != sv.y || dv.z != sv.z) {
src->SetWorldPosition(sv);
}
return;
}
Vector panic=sv;
Vector panic = sv;
static Transform y_tform;
const Vector &radii=src->getCollisionRadii();
const Vector &radii = src->getCollisionRadii();
float radius=radii.x,inv_y_scale;
float y_scale=inv_y_scale=y_tform.m.j.y=1;
float radius = radii.x, inv_y_scale;
float y_scale = inv_y_scale = y_tform.m.j.y = 1;
if( radii.x!=radii.y ){
y_scale=y_tform.m.j.y=radius/radii.y;
inv_y_scale=1/y_scale;
sv.y*=y_scale;
dv.y*=y_scale;
if (radii.x != radii.y) {
y_scale = y_tform.m.j.y = radius / radii.y;
inv_y_scale = 1 / y_scale;
sv.y *= y_scale;
dv.y *= y_scale;
}
int n_hit=0;
int n_hit = 0;
Plane planes[2];
Line coll_line( sv,dv-sv );
Vector dir=coll_line.d;
Line coll_line(sv, dv - sv);
Vector dir = coll_line.d;
float td=coll_line.d.length();
float td_xz=Vector( coll_line.d.x,0,coll_line.d.z ).length();
float td = coll_line.d.length();
float td_xz = Vector(coll_line.d.x, 0, coll_line.d.z).length();
const vector<CollInfo> &collinfos=_collInfo[src->getCollisionType()];
int hits=0;
for(;;){
const vector<CollInfo> &collinfos = _collInfo[src->getCollisionType()];
int hits = 0;
for (;;) {
Collision coll;
Object *coll_obj=0;
vector<CollInfo>::const_iterator coll_it,coll_info;
Object *coll_obj = 0;
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];
const Transform &dst_tform = dst->getPrevWorldTform();
for( dst_it=dst_objs.begin();dst_it!=dst_objs.end();++dst_it ){
Object *dst=*dst_it;
if( src==dst ) continue;
const Transform &dst_tform=dst->getPrevWorldTform();
if( y_scale==1 ){
if( hitTest(
coll_line,radius,dst,dst_tform,
coll_it->method,&coll ) ){
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{
if( hitTest(
coll_line,radius,dst,y_tform * dst_tform,
coll_it->method,&coll ) ){
coll_obj=dst;
coll_info=coll_it;
} else {
if (hitTest(
coll_line, radius, dst, y_tform * dst_tform,
coll_it->method, &coll)) {
coll_obj = dst;
coll_info = coll_it;
}
}
}
}
if( !coll_obj ) break;
if (!coll_obj) break;
//register collision
if( ++hits==MAX_HITS ){
if (++hits == WORLD_COLLISION_HITS) {
// exit(0);
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.time=coll_plane.t_intersect( coll_line );
coll_plane.d -= COLLISION_FLT_EPSILON;
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!
sv=coll_line*coll.time;
td*=1-coll.time;
td_xz*=1-coll.time;
sv = coll_line*coll.time;
td *= 1 - coll.time;
td_xz *= 1 - coll.time;
}
if( coll_info->response==COLLISION_RESPONSE_STOP ){
dv=sv;
if (coll_info->response == COLLISION_RESPONSE_STOP) {
dv = sv;
break;
}
//find nearest point on plane to dest
Vector nv=coll_plane.nearest( dv );
Vector nv = coll_plane.nearest(dv);
if( n_hit==0 ){
dv=nv;
}else if( n_hit==1 ){
if( planes[0].distance(nv)>=0 ){
dv=nv;n_hit=0;
}else if( fabs( planes[0].n.dot( coll_plane.n ) )<1-FLT_EPSILON ){
dv=coll_plane.intersect( planes[0] ).nearest( dv );
}else{
if (n_hit == 0) {
dv = nv;
} else if (n_hit == 1) {
if (planes[0].distance(nv) >= 0) {
dv = nv; n_hit = 0;
} else if (fabs(planes[0].n.dot(coll_plane.n)) < 1 - FLT_EPSILON) {
dv = coll_plane.intersect(planes[0]).nearest(dv);
} else {
//SQUISHED!
//exit(0);
hits=MAX_HITS;break;
hits = WORLD_COLLISION_HITS; break;
}
}else if( planes[0].distance(nv)>=0 && planes[1].distance(nv)>=0 ){
dv=nv;n_hit=0;
}else{
dv=sv;break;
} else if (planes[0].distance(nv) >= 0 && planes[1].distance(nv) >= 0) {
dv = nv; n_hit = 0;
} else {
dv = sv; break;
}
Vector dd( dv-sv );
Vector dd(dv - sv);
//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 ){
float d=dd.length();
if( d<= FLT_EPSILON ){ dv=sv;break; }
if( d>td ) dd*=td/d;
}else if( coll_info->response==COLLISION_RESPONSE_SLIDEXZ ){
float d=Vector( dd.x,0,dd.z ).length();
if( d<= FLT_EPSILON ){ dv=sv;break; }
if( d>td_xz ) dd*=td_xz/d;
if (coll_info->response == COLLISION_RESPONSE_SLIDE) {
float d = dd.length();
if (d <= FLT_EPSILON) { dv = sv; break; }
if (d > td) dd *= td / d;
} else if (coll_info->response == COLLISION_RESPONSE_SLIDEXZ) {
float d = Vector(dd.x, 0, dd.z).length();
if (d <= FLT_EPSILON) { dv = sv; break; }
if (d > td_xz) dd *= td_xz / d;
}
coll_line.o=sv;
coll_line.d=dd;dv=sv+dd;
planes[n_hit++]=coll_plane;
coll_line.o = sv;
coll_line.d = dd; dv = sv + dd;
planes[n_hit++] = coll_plane;
}
if( hits ){
if( hits<MAX_HITS ){
dv.y*=inv_y_scale;
src->setWorldPosition( dv );
}else{
src->setWorldPosition( panic );
if (hits) {
if (hits < WORLD_COLLISION_HITS) {
dv.y *= inv_y_scale;
src->SetWorldPosition(dv);
} else {
src->SetWorldPosition(panic);
}
}
}
@@ -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() ){
free_colls.push_back( used_colls.back() );
for (; used_colls.size(); used_colls.pop_back()) {
free_colls.push_back(used_colls.back());
}
enumEnabled();
StaticEnumerateEnabled();
vector<Object*>::const_iterator it;
for( it=_enabled.begin();it!=_enabled.end();++it ){
Object *o=*it;
if( int n=o->getCollisionType() ){
_objsByType[n].push_back(o);
for (Object* o : s_objectsEnabled) {
if (int n = o->getCollisionType()) {
_objsByTypeSwappable[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();
}
for( int k=0;k<1000;++k ){
_objsByType[k].clear();
for (int k = 0; k < WORLD_COLLISION_TYPES; ++k) {
_objsByTypeSwappable[k].swap(_objsByType[k]);
_objsByTypeSwappable[k].clear();
}
}
@@ -505,85 +481,81 @@ static vector<gxLight*> _lights;
static vector<Mirror*> _mirrors;
static vector<Listener*> _listeners;
struct OrderComp{
bool operator()( Object *a,Object *b ){
return a->getOrder()<b->getOrder();
struct OrderComp {
bool operator()(Object *a, Object *b) {
return a->getOrder() < b->getOrder();
}
};
struct TransComp{
bool operator()( Model *a,Model *b )const{
struct TransComp {
bool operator()(Model *a, Model *b)const {
return
cam_tform.v.distance( a->getRenderTform().v )<
cam_tform.v.distance( b->getRenderTform().v );
cam_tform.v.distance(a->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( it=_visible.begin();it!=_visible.end();++it ){
(*it)->capture();
for (Object* o : s_objectsVisible) {
o->capture();
}
}
void World::render( float tween ){
void World::render(float tween) {
//set render tweens, and build ordered and unordered model lists...
ord_mods.clear();
unord_mods.clear();
_visible.clear();
s_objectsVisible.clear();
_lights.clear();
_mirrors.clear();
_listeners.clear();
enumVisible();
StaticEnumerateVisible();
vector<Object*>::const_iterator it;
for( it=_visible.begin();it!=_visible.end();++it ){
Object *o=*it;
for (Object* o : s_objectsVisible) {
if (!o->beginRender(tween)) continue;
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);
else if( Mirror *t=o->getMirror() ) _mirrors.push_back(t);
else if( Listener *t=o->getListener() ) _listeners.push_back(t);
else if( Model *t=o->getModel() ){
if( t->getOrder() ) ord_que.push( t );
else unord_mods.push_back( t );
if (Light *t = o->getLight()) _lights.push_back(t->getGxLight());
else if (Camera *t = o->getCamera()) cam_que.push(t);
else if (Mirror *t = o->getMirror()) _mirrors.push_back(t);
else if (Listener *t = o->getListener()) _listeners.push_back(t);
else if (Model *t = o->getModel()) {
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" );
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;
for( mir_it=_mirrors.begin();mir_it!=_mirrors.end();++mir_it ){
render( cam,*mir_it );
for (mir_it = _mirrors.begin(); mir_it != _mirrors.end(); ++mir_it) {
render(cam, *mir_it);
}
render( cam,0 );
render(cam, 0);
}
gx_scene->end();
@@ -591,87 +563,87 @@ void World::render( float tween ){
// gx_runtime->debugLog( "End RenderWorld" );
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();
}
}
void World::render( Camera *cam,Mirror *mirror ){
void World::render(Camera *cam, Mirror *mirror) {
if( mirror ){
const Transform &t=mirror->getRenderTform();
cam_tform=t * Transform( scaleMatrix( 1,-1,1 ) ) * -t * cam->getRenderTform();
gx_scene->setFlippedTris( true );
}else{
cam_tform=cam->getRenderTform();
gx_scene->setFlippedTris( false );
if (mirror) {
const Transform &t = mirror->getRenderTform();
cam_tform = t * Transform(scaleMatrix(1, -1, 1)) * -t * cam->getRenderTform();
gx_scene->setFlippedTris(true);
} else {
cam_tform = cam->getRenderTform();
gx_scene->setFlippedTris(false);
}
//set camera matrix
gx_scene->setViewMatrix( (gxScene::Matrix*)&(-cam_tform) );
gx_scene->setViewMatrix((gxScene::Matrix*)&(-cam_tform));
//initialize render context
RenderContext rc( cam_tform,cam->getFrustum(),mirror!=0 );
RenderContext rc(cam_tform, cam->getFrustum(), mirror != 0);
//draw everything in order
int ord=0;
gx_scene->setZMode( gxScene::ZMODE_DISABLE );
while( ord<ord_mods.size() && ord_mods[ord]->getOrder()>0 ){
Model *mod=ord_mods[ord++];
if( !mod->doAutoFade( cam_tform.v ) ) continue;
render( mod,rc );
size_t ord = 0;
gx_scene->setZMode(gxScene::ZMODE_DISABLE);
while (ord < ord_mods.size() && ord_mods[ord]->getOrder()>0) {
Model *mod = ord_mods[ord++];
if (!mod->doAutoFade(cam_tform.v)) continue;
render(mod, rc);
flushTransparent();
}
gx_scene->setZMode( gxScene::ZMODE_NORMAL );
for( int k=0;k<unord_mods.size();++k ){
Model *mod=unord_mods[k];
if( !mod->doAutoFade( cam_tform.v ) ) continue;
render( mod,rc );
gx_scene->setZMode(gxScene::ZMODE_NORMAL);
for (size_t k = 0; k < unord_mods.size(); ++k) {
Model *mod = unord_mods[k];
if (!mod->doAutoFade(cam_tform.v)) continue;
render(mod, rc);
}
gx_scene->setZMode( gxScene::ZMODE_CMPONLY );
gx_scene->setZMode(gxScene::ZMODE_CMPONLY);
flushTransparent();
gx_scene->setZMode( gxScene::ZMODE_DISABLE );
while( ord<ord_mods.size() ){
Model *mod=ord_mods[ord++];
if( !mod->doAutoFade( cam_tform.v ) ) continue;
render( mod,rc );
gx_scene->setZMode(gxScene::ZMODE_DISABLE);
while (ord < ord_mods.size()) {
Model *mod = ord_mods[ord++];
if (!mod->doAutoFade(cam_tform.v)) continue;
render(mod, rc);
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->getRenderSpace()==Model::RENDER_SPACE_LOCAL ){
gx_scene->setWorldMatrix( (gxScene::Matrix*)&mod->getRenderTform() );
}else{
gx_scene->setWorldMatrix( 0 );
if (mod->queueSize(Model::QUEUE_OPAQUE)) {
if (mod->getRenderSpace() == Model::RENDER_SPACE_LOCAL) {
gx_scene->setWorldMatrix((gxScene::Matrix*)&mod->getRenderTform());
} else {
gx_scene->setWorldMatrix(0);
}
mod->renderQueue( Model::QUEUE_OPAQUE );
mod->renderQueue(Model::QUEUE_OPAQUE);
}
if( trans || mod->queueSize( Model::QUEUE_TRANSPARENT ) ){
transparents.push( mod );
if (trans || mod->queueSize(Model::QUEUE_TRANSPARENT)) {
transparents.push(mod);
}
}
void World::flushTransparent(){
void World::flushTransparent() {
bool local=true;
bool local = true;
for( ;transparents.size();transparents.pop() ){
Model *mod=transparents.top();
if( mod->getRenderSpace()==Model::RENDER_SPACE_LOCAL ){
gx_scene->setWorldMatrix( (gxScene::Matrix*)&mod->getRenderTform() );
local=true;
}else if( local ){
gx_scene->setWorldMatrix( 0 );
local=false;
for (; transparents.size(); transparents.pop()) {
Model *mod = transparents.top();
if (mod->getRenderSpace() == Model::RENDER_SPACE_LOCAL) {
gx_scene->setWorldMatrix((gxScene::Matrix*)&mod->getRenderTform());
local = true;
} else if (local) {
gx_scene->setWorldMatrix(0);
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 "listener.h"
#define WORLD_COLLISION_TYPES 16
#define WORLD_COLLISION_HITS 4
class World{
public:
//collision methods
@@ -34,7 +37,7 @@ public:
void capture();
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 );
Object *traceRay( const Line &line,float radius,ObjCollision *curr_coll );
@@ -43,8 +46,9 @@ private:
int dst_type,method,response;
};
vector<CollInfo> _collInfo[1000];
vector<Object*> _objsByType[1000];
vector<CollInfo> _collInfo[WORLD_COLLISION_TYPES];
std::list<Object*> _objsByType[WORLD_COLLISION_TYPES];
std::list<Object*> _objsByTypeSwappable[WORLD_COLLISION_TYPES];
void collide( Object *src );
void render( Camera *c,Mirror *m );
compiler/declnode.cpp
+8 -10
View File
@@ -6,7 +6,7 @@
// Sequence of declarations //
//////////////////////////////
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) {
if (x.pos < 0) x.pos = decls[k]->pos;
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) {
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) {
if (x.pos < 0) x.pos = decls[k]->pos;
if (!x.file.size()) x.file = decls[k]->file;
@@ -26,7 +26,7 @@ void DeclSeqNode::semant(Environ *e) {
}
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) {
if (x.pos < 0) x.pos = decls[k]->pos;
if (!x.file.size()) x.file = decls[k]->file;
@@ -36,7 +36,7 @@ void DeclSeqNode::translate(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) {
if (x.pos < 0) x.pos = decls[k]->pos;
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);
}
void VarDeclNode::semant(Environ *e) {
}
void VarDeclNode::semant(Environ *e) {}
void VarDeclNode::translate(Codegen *g) {
if (kind & DECL_GLOBAL) {
@@ -149,7 +148,7 @@ void FuncDeclNode::translate(Codegen *g) {
//translate statements
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);
}
@@ -224,8 +223,7 @@ void DataDeclNode::proto(DeclSeq *d, Environ *e) {
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) {
if (expr->sem_type != Type::string_type) return;
@@ -275,7 +273,7 @@ void VectorDeclNode::translate(Codegen *g) {
VectorType *v = sem_type->vectorType();
g->i_data(6, v->label);
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);
string t;
Type *type = v->elementType;