diff --git a/build/gamesource/levels/stalker_atp/stalker_atp.ent b/build/gamesource/levels/stalker_atp/stalker_atp.ent index 155794ca1da9e55d6c44d929d0ad464a56184712..25103e01dd44ee7a289ca3e66f8b067b2fcfbc87 100644 --- a/build/gamesource/levels/stalker_atp/stalker_atp.ent +++ b/build/gamesource/levels/stalker_atp/stalker_atp.ent @@ -266,6 +266,7 @@ rotation = 0.000000 0.980603 0.000000 -0.196004 team = 0 [ent_21] +skin = 0 OnTouchStart = OnTouchEndAll = OnTouchEnd = diff --git a/build/gamesource/levels/stalker_atp/stalker_atp.lvl b/build/gamesource/levels/stalker_atp/stalker_atp.lvl index 6d983de410865d9dc8f665cf68ff40ba479ccf28..f06861b40e476d411c925b76ae1c11a5f25acde8 100644 --- a/build/gamesource/levels/stalker_atp/stalker_atp.lvl +++ b/build/gamesource/levels/stalker_atp/stalker_atp.lvl @@ -1,6 +1,5 @@ [level] geometry = stalker_atp.geom ---green = stalker_atp.green type = outdoor entity = stalker_atp.ent aigrid = stalker_atp.aigrid diff --git a/build/gamesource/levels/stalker_atp/stalker_atp.phy b/build/gamesource/levels/stalker_atp/stalker_atp.phy index 642b5466b216877e12e6452b14c63c513d5825d8..b79cd15a4c5c90330d6e99efdcd53a2b8c105df0 100644 Binary files a/build/gamesource/levels/stalker_atp/stalker_atp.phy and b/build/gamesource/levels/stalker_atp/stalker_atp.phy differ diff --git a/build/gamesource/levels/stalker_atp/stalker_atp.phym b/build/gamesource/levels/stalker_atp/stalker_atp.phym index c098a3a15f425bb3b8643e497b45786d80cfda12..c8315b1d84efe4bf28b6b4507a4c0b072b067115 100644 Binary files a/build/gamesource/levels/stalker_atp/stalker_atp.phym and b/build/gamesource/levels/stalker_atp/stalker_atp.phym differ diff --git a/proj/SkyXEngine/vs2013/SkyXEngine.sln b/proj/SkyXEngine/vs2013/SkyXEngine.sln index 2b2acaea1e1c73cbfe800a9f58525b52cd3f2131..23b8350cc184c2b0556ea002c8d91aa7ee1c8c37 100644 --- a/proj/SkyXEngine/vs2013/SkyXEngine.sln +++ b/proj/SkyXEngine/vs2013/SkyXEngine.sln @@ -20,6 +20,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SkyXEngine", "SkyXEngine.vc {7F0ACED1-6E16-4DD3-800E-0C50150897C2} = {7F0ACED1-6E16-4DD3-800E-0C50150897C2} {AEECC2DB-C7C7-4089-9262-A69794DF834D} = {AEECC2DB-C7C7-4089-9262-A69794DF834D} {56A8D7F7-B73C-4206-8038-83D8A169AA2F} = {56A8D7F7-B73C-4206-8038-83D8A169AA2F} + {8144D5F8-07D0-4663-AAAE-11053614FAC5} = {8144D5F8-07D0-4663-AAAE-11053614FAC5} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxcore", "..\..\sxcore\vs2013\sxcore.vcxproj", "{C1C1F046-C839-4602-AF70-923CDD237C1B}" @@ -41,11 +42,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxinput", "..\..\sxinput\vs {C1C1F046-C839-4602-AF70-923CDD237C1B} = {C1C1F046-C839-4602-AF70-923CDD237C1B} EndProjectSection EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxmtllight", "..\..\sxmtllight\vs2013\sxmtllight.vcxproj", "{2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}" - ProjectSection(ProjectDependencies) = postProject - {AEECC2DB-C7C7-4089-9262-A69794DF834D} = {AEECC2DB-C7C7-4089-9262-A69794DF834D} - EndProjectSection -EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxpp", "..\..\sxpp\vs2013\sxpp.vcxproj", "{BA779DCC-93C8-4FB7-BBB9-A7D2F76C35DE}" ProjectSection(ProjectDependencies) = postProject {AEECC2DB-C7C7-4089-9262-A69794DF834D} = {AEECC2DB-C7C7-4089-9262-A69794DF834D} @@ -98,6 +94,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxphysics", "..\..\sxphysic {E74F00B5-7DC5-DC48-8E91-D1C2296F455F} = {E74F00B5-7DC5-DC48-8E91-D1C2296F455F} {0C7E3DB7-005F-41E9-A570-868BCF959E91} = {0C7E3DB7-005F-41E9-A570-868BCF959E91} {072A60D2-317A-CC41-AD12-7E381235064A} = {072A60D2-317A-CC41-AD12-7E381235064A} + {8144D5F8-07D0-4663-AAAE-11053614FAC5} = {8144D5F8-07D0-4663-AAAE-11053614FAC5} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BulletDynamics", "..\..\..\sdks\bullet3\build3\vs2010\BulletDynamics.vcxproj", "{072A60D2-317A-CC41-AD12-7E381235064A}" @@ -140,6 +137,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxgame", "..\..\sxgame\vs20 {3A5449A3-DCE7-4557-9C9F-DEEAFBAAC763} = {3A5449A3-DCE7-4557-9C9F-DEEAFBAAC763} {120D29B8-D2D9-4B4E-8AC6-D951973B7398} = {120D29B8-D2D9-4B4E-8AC6-D951973B7398} {56A8D7F7-B73C-4206-8038-83D8A169AA2F} = {56A8D7F7-B73C-4206-8038-83D8A169AA2F} + {8144D5F8-07D0-4663-AAAE-11053614FAC5} = {8144D5F8-07D0-4663-AAAE-11053614FAC5} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxdecals", "..\..\sxdecals\vs2013\sxdecals.vcxproj", "{B9656841-7734-4D0B-8619-1BED5E2ED7AE}" @@ -147,6 +145,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxdecals", "..\..\sxdecals\ {7C0C8205-BDD3-44A3-AA3A-7855C7EFC88E} = {7C0C8205-BDD3-44A3-AA3A-7855C7EFC88E} {C1C1F046-C839-4602-AF70-923CDD237C1B} = {C1C1F046-C839-4602-AF70-923CDD237C1B} {AEECC2DB-C7C7-4089-9262-A69794DF834D} = {AEECC2DB-C7C7-4089-9262-A69794DF834D} + {8144D5F8-07D0-4663-AAAE-11053614FAC5} = {8144D5F8-07D0-4663-AAAE-11053614FAC5} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxparticleseditor", "..\..\sxparticleseditor\vs2013\sxparticleseditor.vcxproj", "{B66C63CA-62E0-472F-9D24-070CAC7C8B12}" @@ -177,6 +176,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxrender", "..\..\sxrender\ {0C7E3DB7-005F-41E9-A570-868BCF959E91} = {0C7E3DB7-005F-41E9-A570-868BCF959E91} {BA779DCC-93C8-4FB7-BBB9-A7D2F76C35DE} = {BA779DCC-93C8-4FB7-BBB9-A7D2F76C35DE} {56A8D7F7-B73C-4206-8038-83D8A169AA2F} = {56A8D7F7-B73C-4206-8038-83D8A169AA2F} + {8144D5F8-07D0-4663-AAAE-11053614FAC5} = {8144D5F8-07D0-4663-AAAE-11053614FAC5} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxgenpreview", "..\..\sxgenpreview\vs2013\sxgenpreview.vcxproj", "{D381001E-C1FF-415F-A269-5264AD9013D5}" @@ -190,6 +190,13 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "freetype-2.6", "freetype-2. EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "freetype", "..\..\..\sdks\freetype-2.6\builds\windows\vc2013\freetype.vcxproj", "{78B079BD-9FC7-4B9E-B4A6-96DA0F00248B}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxmtrl", "..\..\sxmtrl\vs2013\sxmtrl.vcxproj", "{8144D5F8-07D0-4663-AAAE-11053614FAC5}" + ProjectSection(ProjectDependencies) = postProject + {AEECC2DB-C7C7-4089-9262-A69794DF834D} = {AEECC2DB-C7C7-4089-9262-A69794DF834D} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxlight", "..\..\sxlight\vs2013\sxlight.vcxproj", "{2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug Multithreaded|Win32 = Debug Multithreaded|Win32 @@ -313,27 +320,6 @@ Global {3A5449A3-DCE7-4557-9C9F-DEEAFBAAC763}.Release|Win32.ActiveCfg = Release|Win32 {3A5449A3-DCE7-4557-9C9F-DEEAFBAAC763}.Release|Win32.Build.0 = Release|Win32 {3A5449A3-DCE7-4557-9C9F-DEEAFBAAC763}.Release|x64.ActiveCfg = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Multithreaded|Win32.ActiveCfg = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Multithreaded|Win32.Build.0 = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Multithreaded|x64.ActiveCfg = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Singlethreaded|Win32.ActiveCfg = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Singlethreaded|Win32.Build.0 = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Singlethreaded|x64.ActiveCfg = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug|Win32.ActiveCfg = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug|Win32.Build.0 = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug|x64.ActiveCfg = Debug|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Multithreaded|Win32.ActiveCfg = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Multithreaded|Win32.Build.0 = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Multithreaded|x64.ActiveCfg = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Singlethreaded|Win32.ActiveCfg = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Singlethreaded|Win32.Build.0 = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Singlethreaded|x64.ActiveCfg = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release SM16|Win32.ActiveCfg = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release SM16|Win32.Build.0 = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release SM16|x64.ActiveCfg = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release|Win32.ActiveCfg = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release|Win32.Build.0 = Release|Win32 - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release|x64.ActiveCfg = Release|Win32 {BA779DCC-93C8-4FB7-BBB9-A7D2F76C35DE}.Debug Multithreaded|Win32.ActiveCfg = Debug|Win32 {BA779DCC-93C8-4FB7-BBB9-A7D2F76C35DE}.Debug Multithreaded|Win32.Build.0 = Debug|Win32 {BA779DCC-93C8-4FB7-BBB9-A7D2F76C35DE}.Debug Multithreaded|x64.ActiveCfg = Debug|Win32 @@ -1097,6 +1083,48 @@ Global {78B079BD-9FC7-4B9E-B4A6-96DA0F00248B}.Release|Win32.Build.0 = Release|Win32 {78B079BD-9FC7-4B9E-B4A6-96DA0F00248B}.Release|x64.ActiveCfg = Release|x64 {78B079BD-9FC7-4B9E-B4A6-96DA0F00248B}.Release|x64.Build.0 = Release|x64 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug Multithreaded|Win32.ActiveCfg = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug Multithreaded|Win32.Build.0 = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug Multithreaded|x64.ActiveCfg = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug Singlethreaded|Win32.ActiveCfg = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug Singlethreaded|Win32.Build.0 = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug Singlethreaded|x64.ActiveCfg = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug|Win32.ActiveCfg = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug|Win32.Build.0 = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Debug|x64.ActiveCfg = Debug|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release Multithreaded|Win32.ActiveCfg = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release Multithreaded|Win32.Build.0 = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release Multithreaded|x64.ActiveCfg = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release Singlethreaded|Win32.ActiveCfg = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release Singlethreaded|Win32.Build.0 = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release Singlethreaded|x64.ActiveCfg = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release SM16|Win32.ActiveCfg = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release SM16|Win32.Build.0 = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release SM16|x64.ActiveCfg = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release|Win32.ActiveCfg = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release|Win32.Build.0 = Release|Win32 + {8144D5F8-07D0-4663-AAAE-11053614FAC5}.Release|x64.ActiveCfg = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Multithreaded|Win32.ActiveCfg = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Multithreaded|Win32.Build.0 = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Multithreaded|x64.ActiveCfg = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Singlethreaded|Win32.ActiveCfg = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Singlethreaded|Win32.Build.0 = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug Singlethreaded|x64.ActiveCfg = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug|Win32.ActiveCfg = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug|Win32.Build.0 = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Debug|x64.ActiveCfg = Debug|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Multithreaded|Win32.ActiveCfg = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Multithreaded|Win32.Build.0 = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Multithreaded|x64.ActiveCfg = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Singlethreaded|Win32.ActiveCfg = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Singlethreaded|Win32.Build.0 = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release Singlethreaded|x64.ActiveCfg = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release SM16|Win32.ActiveCfg = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release SM16|Win32.Build.0 = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release SM16|x64.ActiveCfg = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release|Win32.ActiveCfg = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release|Win32.Build.0 = Release|Win32 + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}.Release|x64.ActiveCfg = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1106,7 +1134,6 @@ Global {AEECC2DB-C7C7-4089-9262-A69794DF834D} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} {0C7E3DB7-005F-41E9-A570-868BCF959E91} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} {3A5449A3-DCE7-4557-9C9F-DEEAFBAAC763} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} - {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} {BA779DCC-93C8-4FB7-BBB9-A7D2F76C35DE} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} {0292BE32-298E-4E18-BC42-5A39F9487EBA} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} {709D8A7A-D3E0-4070-A493-EFDF7A8E9D73} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} @@ -1122,6 +1149,8 @@ Global {7F0ACED1-6E16-4DD3-800E-0C50150897C2} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} {8AA0585B-D6E4-46B4-9183-3BACD5B9D47F} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} {2D039A6D-B874-4AA7-8F89-E86DD70B21ED} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} + {8144D5F8-07D0-4663-AAAE-11053614FAC5} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} + {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D} = {13D5622C-8643-4BD8-A730-B5C919DAFDDC} {6A3341BF-710B-4310-A7F8-810040D698DC} = {5128FBE9-1706-4255-B422-4A652320085E} {AFBF200A-9260-4469-AE64-DCB42C796DD6} = {5128FBE9-1706-4255-B422-4A652320085E} {A2B9EACA-69C1-4E9D-AF3C-704608DB57DE} = {5128FBE9-1706-4255-B422-4A652320085E} diff --git a/proj/sxgcore/vs2013/sxgcore.vcxproj b/proj/sxgcore/vs2013/sxgcore.vcxproj index 75c7b89c332148c000135b1fdb47ee959f8d31e4..8651a9846f724545a85cf83569ac69afc21ade2d 100644 --- a/proj/sxgcore/vs2013/sxgcore.vcxproj +++ b/proj/sxgcore/vs2013/sxgcore.vcxproj @@ -108,12 +108,15 @@ false false + + false false + false false @@ -135,10 +138,13 @@ + + + diff --git a/proj/sxgcore/vs2013/sxgcore.vcxproj.filters b/proj/sxgcore/vs2013/sxgcore.vcxproj.filters index 36cfc4945d92bdeac9c628ef69a25010247a1c0e..1258050140cadf9a02145ef897858bbba72a2f99 100644 --- a/proj/sxgcore/vs2013/sxgcore.vcxproj.filters +++ b/proj/sxgcore/vs2013/sxgcore.vcxproj.filters @@ -40,6 +40,15 @@ Source + + Source + + + Source + + + Source + @@ -89,5 +98,14 @@ Header + + Header + + + Header + + + Header + \ No newline at end of file diff --git a/proj/sxgui/vs2013/sxgui.vcxproj b/proj/sxgui/vs2013/sxgui.vcxproj index ef452e6e9ddae0ff1683b9a771c349e3dd0a5341..0b564287181a4cc7b1b80d088fbd2e81bb89f736 100644 --- a/proj/sxgui/vs2013/sxgui.vcxproj +++ b/proj/sxgui/vs2013/sxgui.vcxproj @@ -68,6 +68,7 @@ ../../../libs/$(TargetName).lib true + $(ProjectDir)$(TargetName).pdb $(OutDir)$(TargetName)d$(TargetExt) diff --git a/proj/sxmtllight/vs2013/sxmtllight.sln b/proj/sxlight/vs2013/sxlight.sln similarity index 86% rename from proj/sxmtllight/vs2013/sxmtllight.sln rename to proj/sxlight/vs2013/sxlight.sln index 766634348aa27f7a15af2b1a95edd75346097e14..9679e4bb20b5d07de99250b81cfc843afc8d2989 100644 --- a/proj/sxmtllight/vs2013/sxmtllight.sln +++ b/proj/sxlight/vs2013/sxlight.sln @@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 2013 VisualStudioVersion = 12.0.21005.1 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxmtllight", "sxmtllight.vcxproj", "{2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}" +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sxlight", "sxlight.vcxproj", "{2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/proj/sxmtllight/vs2013/sxmtllight.vcxproj b/proj/sxlight/vs2013/sxlight.vcxproj similarity index 79% rename from proj/sxmtllight/vs2013/sxmtllight.vcxproj rename to proj/sxlight/vs2013/sxlight.vcxproj index 5007ecf9bee20d1cea8b811a8b8eef1593ea0363..40321617421b17999aa5fa9ec8615c9ed1fee0b4 100644 --- a/proj/sxmtllight/vs2013/sxmtllight.vcxproj +++ b/proj/sxlight/vs2013/sxlight.vcxproj @@ -13,7 +13,8 @@ {2B3BA583-D5EC-4DC2-91CF-42B1C7ADFD9D} Win32Proj - sxmtllight + sxlight + sxlight @@ -60,7 +61,7 @@ Level3 Disabled - WIN32;_DEBUG;_WINDOWS;_USRDLL;SXMTLLIGHT_EXPORTS;SX_DLL;%(PreprocessorDefinitions);SX_LIB_NAME="MTLLIGHT" + WIN32;_DEBUG;_WINDOWS;_USRDLL;SXLIGHT_EXPORTS;SX_DLL;%(PreprocessorDefinitions);SX_LIB_NAME="LIGHT" MultiThreadedDebug ProgramDatabase 4316 @@ -81,7 +82,7 @@ MaxSpeed true true - WIN32;NDEBUG;_WINDOWS;_USRDLL;SXMTLLIGHT_EXPORTS;SX_EXE;%(PreprocessorDefinitions);SX_LIB_NAME="MTLLIGHT" + WIN32;NDEBUG;_WINDOWS;_USRDLL;SXLIGHT_EXPORTS;SX_EXE;%(PreprocessorDefinitions);SX_LIB_NAME="LIGHT" MultiThreaded 4316 @@ -98,42 +99,32 @@ - + false false - + false false - + false false - + false false - - false - false - - - false - false - - + - - - - - - + + + + diff --git a/proj/sxmtllight/vs2013/sxmtllight.vcxproj.filters b/proj/sxlight/vs2013/sxlight.vcxproj.filters similarity index 61% rename from proj/sxmtllight/vs2013/sxmtllight.vcxproj.filters rename to proj/sxlight/vs2013/sxlight.vcxproj.filters index 4990307c104a7da2d9c51939f38654e07ea7ab7f..14e398cee7514767418a2149ad0c1a58493cb31e 100644 --- a/proj/sxmtllight/vs2013/sxmtllight.vcxproj.filters +++ b/proj/sxlight/vs2013/sxlight.vcxproj.filters @@ -1,23 +1,16 @@  - - + Source - + Source - + Source - - Source - - - Source - - + Source @@ -29,6 +22,9 @@ Source + + Source + @@ -39,22 +35,16 @@ - - Headers - - - Headers - - + Headers - + Headers - + Headers - + Headers diff --git a/proj/sxmtrl/vs2013/sxmtrl.vcxproj b/proj/sxmtrl/vs2013/sxmtrl.vcxproj new file mode 100644 index 0000000000000000000000000000000000000000..5a9838a5a7f32fd9c3369e334209562eb13a1474 --- /dev/null +++ b/proj/sxmtrl/vs2013/sxmtrl.vcxproj @@ -0,0 +1,115 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {8144D5F8-07D0-4663-AAAE-11053614FAC5} + Win32Proj + sxmtrl + + + + DynamicLibrary + true + v120_xp + MultiByte + + + DynamicLibrary + false + v120_xp + true + MultiByte + + + + + + + + + + + + + false + ../../../build/ + $(ProjectName)_d + ../../../source;$(VC_IncludePath);$(WindowsSDK_IncludePath);../../../sdks/dx9sdk/Include + ../../../libs;$(LibraryPath);$(WindowsSDK_LibraryPath_x86);../../../sdks/dx9sdk/Lib + ../../../source;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);../../../sdks/dx9sdk/Include + + + false + ../../../build/ + ../../../source;$(VC_IncludePath);$(WindowsSDK_IncludePath);../../../sdks/dx9sdk/Include + ../../../libs;$(LibraryPath);$(WindowsSDK_LibraryPath_x86);../../../sdks/dx9sdk/Lib + ../../../source;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);../../../sdks/dx9sdk/Include + + + + + + Level1 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SXMTRL_EXPORTS;SX_LIB_NAME="LIGHT";%(PreprocessorDefinitions) + MultiThreadedDebug + + + Windows + true + $(ProjectDir)$(TargetName).pdb + ../../../libs/$(TargetName).lib + + + + + Level1 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SXMTRL_EXPORTS;SX_LIB_NAME="LIGHT";%(PreprocessorDefinitions) + MultiThreaded + + + Windows + false + true + true + $(ProjectDir)$(TargetName).pdb + ../../../libs/$(TargetName).lib + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/proj/sxmtrl/vs2013/sxmtrl.vcxproj.filters b/proj/sxmtrl/vs2013/sxmtrl.vcxproj.filters new file mode 100644 index 0000000000000000000000000000000000000000..95a3241c2266b3485dcfbdb6fb6549143d025a1a --- /dev/null +++ b/proj/sxmtrl/vs2013/sxmtrl.vcxproj.filters @@ -0,0 +1,66 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/CL.read.1.tlog b/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/CL.read.1.tlog deleted file mode 100644 index 21ad67b7f01edf6208209b2214e1f95aca02589c..0000000000000000000000000000000000000000 Binary files a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/CL.read.1.tlog and /dev/null differ diff --git a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/Lib-link.read.1.tlog b/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/Lib-link.read.1.tlog deleted file mode 100644 index 196a4fcb4d469df26a8779d9f8cb52dce1e26fca..0000000000000000000000000000000000000000 Binary files a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/Lib-link.read.1.tlog and /dev/null differ diff --git a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/Lib-link.write.1.tlog b/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/Lib-link.write.1.tlog deleted file mode 100644 index 5eb96e361355e475c1fac75e8ebd31ad19545eae..0000000000000000000000000000000000000000 Binary files a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/Lib-link.write.1.tlog and /dev/null differ diff --git a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/cl.command.1.tlog b/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/cl.command.1.tlog deleted file mode 100644 index 20f668b75be63d882179c2ceb73c99bf4c8a1e98..0000000000000000000000000000000000000000 Binary files a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/cl.command.1.tlog and /dev/null differ diff --git a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/cl.write.1.tlog b/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/cl.write.1.tlog deleted file mode 100644 index 546b9a4abfbd0fea1eab53008c20e64ab18488b6..0000000000000000000000000000000000000000 Binary files a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/cl.write.1.tlog and /dev/null differ diff --git a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/freetype.lastbuildstate b/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/freetype.lastbuildstate deleted file mode 100644 index e34b30b699a2e161b2278900cd8c630bcb963d6b..0000000000000000000000000000000000000000 --- a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/freetype.lastbuildstate +++ /dev/null @@ -1,2 +0,0 @@ -#TargetFrameworkVersion=v4.0:PlatformToolSet=v120:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit -Release Multithreaded|Win32|C:\DSe\DSe\| diff --git a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/lib.command.1.tlog b/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/lib.command.1.tlog deleted file mode 100644 index 2a6469042d9a25e10ed2ba6f780dde4586801a65..0000000000000000000000000000000000000000 Binary files a/sdks/freetype-2.6/objs/vc2010/Win32/Release Multithreaded/freetype.tlog/lib.command.1.tlog and /dev/null differ diff --git a/sdks/freetype-2.6/objs/vc2010/Win32/freetype26MT.lib b/sdks/freetype-2.6/objs/vc2010/Win32/freetype26MT.lib index 9067e68f26af99711fc2fb81295c2b77b8f472c4..a69f157ea5fc58470568e4752771406927e7d911 100644 Binary files a/sdks/freetype-2.6/objs/vc2010/Win32/freetype26MT.lib and b/sdks/freetype-2.6/objs/vc2010/Win32/freetype26MT.lib differ diff --git a/source/SkyXEngine.h b/source/SkyXEngine.h index d0e2556487dfa2a814281f2605c00b90ce1e07be..9df65aff224c4ffa8f6d31e8f496447735b27c36 100644 --- a/source/SkyXEngine.h +++ b/source/SkyXEngine.h @@ -96,7 +96,7 @@ HDR эффект присутсвует. Основной идеей предназначения служила и служит идея о том чтобы предоставляемый инструментарий мог полностью удовлетворять потребностям разработчика, без необходимости со стороны разработчика вникать в детали реализации, но чтобы этот инструментарий имел прозрачную, открытую, свободную, бесплатную лицензию, и разработчик мог спокойно податься в стихию сотворения своего мира. \n Также главенствовал принцип разделения функционала на логические блоки (библиотеки) и после окончания разработки очередного блока он бы выносился в dll (с глаз долой). Однако существенным дополнением являлась идея о том что библиотеки не должны ничего значть о равнозначных себе библиотеках в общей иерархии. -К примеру \ref sxgeom "библиотека статической геометрии и растительности" ничего не знает о \ref sxmtllight "библиотеке материалов", и последняя ничего не знает о первой, однако первая использует функции из второй посредством графического ядра, а вторая осуществляется настройку материалов перед рендером первой.\n +К примеру \ref sxgeom "библиотека статической геометрии и растительности" ничего не знает о \ref sxmtrl "библиотеке материалов", и последняя ничего не знает о первой, однако первая использует функции из второй посредством графического ядра, а вторая осуществляется настройку материалов перед рендером первой.\n Немаловажным моментом являлся ориентир на гибкость. К примеру \ref sxgcore_redefinition_func "переопредляемые функции" в графическом ядре, позволяют настроить на свой лад рендер. \n Ну и пожалуй самая главная идея заключается в полноценной возможности разработки игр с видом от первого лица, с настройкой/перестройкой "под себя" всего рендера. Также к приправе к этому мы руководствовались мыслью о том что скриптеры (коих не мало) могли бы вести разработку игры на своем (доступном им) уровне, со всеми возможностями движка. @@ -107,7 +107,8 @@ HDR эффект присутсвует. \-- \ref sxgcore\n \--- \ref sxgeom\n \--- \ref sxanim\n -\--- \ref sxmtllight\n +\--- \ref sxlight\n +\--- \ref sxmtrl\n \--- \ref sxpp\n \- \ref sxinput\n Все библиотеки представлены файлами dll, что позволяет разделить функционал и реализацию. Также в большинстве случаев библиотеки могут быть вычленены из самого движка и могут использоваться автономно.\n @@ -350,11 +351,18 @@ QT стиль документирования (!) и QT_AUTOBRIEF - корот #include #if defined(_DEBUG) -#pragma comment(lib, "sxmtllight_d.lib") +#pragma comment(lib, "sxlight_d.lib") #else -#pragma comment(lib, "sxmtllight.lib") +#pragma comment(lib, "sxlight.lib") #endif -#include +#include + +#if defined(_DEBUG) +#pragma comment(lib, "sxmtrl_d.lib") +#else +#pragma comment(lib, "sxmtrl.lib") +#endif +#include #if defined(_DEBUG) #pragma comment(lib, "sxparticles_d.lib") @@ -537,6 +545,9 @@ bool SkyXEngine_RFuncAIQuadPhyNavigate(float3_t * pos); //! просчет столкновения частицы с миром bool SkyXEngine_RFuncParticlesPhyCollision(const float3 * lastpos, const float3* nextpos, float3* coll_pos, float3* coll_nrm); +//! просчет столкновения растительности с миром при генерации +bool SkyXEngine_RFuncGreenIntersect(const float3 *pStart, const float3 *pFinish, float3 *pResult); + //!@} //########################################################################## diff --git a/source/SkyXEngine_Build/SkyXEngine_Build.cpp b/source/SkyXEngine_Build/SkyXEngine_Build.cpp index 3c90c1d1079251b92a006cb2cb686c379d0265fb..a98c689d2a8607f3931fe37583780e6277b41765 100644 --- a/source/SkyXEngine_Build/SkyXEngine_Build.cpp +++ b/source/SkyXEngine_Build/SkyXEngine_Build.cpp @@ -19,7 +19,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLin SGCore_SkyCloudsLoadTex("sky_oblaka.dds"); //SGCore_SkyCloudsSetWidthHeightPos(1000, 1000, &float3(0, 0, 0)); - SGCore_OC_SetEnable(false); + //SGCore_OC_SetEnable(false); //SLevel_Load("stalker_atp", true); //SLevel_Load("sga", true); diff --git a/source/common b/source/common index 87e35b5e73a14e15c89cb95b2ecba63951a247b0..a4dc88ffd0720991c2689b7b4209b96ee0e2c33e 160000 --- a/source/common +++ b/source/common @@ -1 +1 @@ -Subproject commit 87e35b5e73a14e15c89cb95b2ecba63951a247b0 +Subproject commit a4dc88ffd0720991c2689b7b4209b96ee0e2c33e diff --git a/source/decals/DecalManager.cpp b/source/decals/DecalManager.cpp index 281fdd004ff472e640d5364d95181bb75308de46..028c954211eef2f5aedfac7e8a83ea07106aad00 100644 --- a/source/decals/DecalManager.cpp +++ b/source/decals/DecalManager.cpp @@ -320,7 +320,7 @@ void DecalManager::shootDecal(DECAL_TYPE type, const float3 & position, ID iMate return; } - pTex = SGCore_LoadTexGetTex(SML_MtlGetTextureID(pMat)); + pTex = SGCore_LoadTexGetTex(SMtrl_MtlGetTextureID(pMat)); if(!pTex) { return; diff --git a/source/decals/sxdecals.h b/source/decals/sxdecals.h index a2690ff35d416c257847a3c809899d0fa6750109..42d34df52b481d121f7e1202d8bf2a3be32b1628 100644 --- a/source/decals/sxdecals.h +++ b/source/decals/sxdecals.h @@ -21,14 +21,14 @@ See the license in LICENSE #include #if defined(_DEBUG) -#pragma comment(lib, "sxmtllight_d.lib") +#pragma comment(lib, "sxmtrl_d.lib") #else -#pragma comment(lib, "sxmtllight.lib") +#pragma comment(lib, "sxmtrl.lib") #endif #undef SX_LIB_API #define SX_LIB_API extern "C" __declspec (dllimport) -#include +#include #ifdef SX_DLL #undef SX_LIB_API diff --git a/source/game/BaseAmmo.cpp b/source/game/BaseAmmo.cpp index c2fd013553b77d388090f95a7a83d12316761c0f..a673f144f6215f2fd7873a56c628913b11856be9 100644 --- a/source/game/BaseAmmo.cpp +++ b/source/game/BaseAmmo.cpp @@ -144,7 +144,7 @@ void CBaseAmmo::fire(const float3 &_vStart, const float3 &_vDir, CBaseCharacter ID idMtl = SXPhysics_GetMtlID(aHitPoints[i].pCollisionObject, &aHitPoints[i].shapeInfo); if(ID_VALID(idMtl) && !aHitPoints[i].isExit) { - float fHitChance = SML_MtlGetHitChance(idMtl); + float fHitChance = SMtrl_MtlGetHitChance(idMtl); if(fHitChance < randf(0.0f, 1.0f)) { int c = 0; @@ -271,7 +271,7 @@ void CBaseAmmo::shootDecal(const float3 &vPos, const float3 &vNormal, ID idMtl) { if(ID_VALID(idMtl)) { - MTLTYPE_PHYSIC type = SML_MtlGetPhysicMaterial(idMtl); + MTLTYPE_PHYSIC type = SMtrl_MtlGetPhysicMaterial(idMtl); DECAL_TYPE decalType = DECAL_TYPE_CONCRETE; switch(type) { @@ -330,8 +330,8 @@ bool CBaseAmmo::shouldRecochet(const float3 &vPos, const float3 &vNormal, const bool isNewSpeedSet = false; if(ID_VALID(idMtl)) { - fDurability = SML_MtlGetDurability(idMtl); // прочность - fDensity = SML_MtlGetDensity(idMtl); // плотность + fDurability = SMtrl_MtlGetDurability(idMtl); // прочность + fDensity = SMtrl_MtlGetDensity(idMtl); // плотность if(fDurability <= 0) { fDurability = 10; diff --git a/source/game/GameData.h b/source/game/GameData.h index 59e15389bdca492690e5af6167a4db76d034405e..22c58cb5e9184d43d2d2eaa6c15f836c07758301 100644 --- a/source/game/GameData.h +++ b/source/game/GameData.h @@ -10,7 +10,7 @@ See the license in LICENSE #include "Player.h" #include "crosshair.h" -#include +#include #include #include "HUDcontroller.h" #include "GameStateManager.h" diff --git a/source/game/LightDirectional.cpp b/source/game/LightDirectional.cpp index 4905d416a7bf092e0ac7c2c9d930c814292371f6..7b76a665d5be74e4cfdd933c48be34848c93537f 100644 --- a/source/game/LightDirectional.cpp +++ b/source/game/LightDirectional.cpp @@ -6,7 +6,7 @@ See the license in LICENSE #include "LightDirectional.h" -#include +#include /*! \skydocent light_directional Направленный источник света @@ -46,7 +46,7 @@ BaseClass(pMgr) m_iShadowType = 1; m_fAngle = SM_PI * 0.4f; m_fRadiusTop = 0.01f; - m_idLight = SML_LigthsCreateDirection(&float3(0, 0, 0), m_fDist, &(float3)m_vColor, &SMQuaternion(-SM_PI, 'z'), m_fRadiusTop, m_fAngle, true); + m_idLight = SLight_CreateDirection(&float3(0, 0, 0), m_fDist, &(float3)m_vColor, &SMQuaternion(-SM_PI, 'z'), m_fRadiusTop, m_fAngle, true); m_isEnable = true; float3 f = LIGHTS_DIR_BASE; @@ -57,52 +57,52 @@ BaseClass(pMgr) CLightDirectional::~CLightDirectional() { - SML_LigthsDeleteLight(m_idLight); + SLight_DeleteLight(m_idLight); } void CLightDirectional::toggleEnable() { m_isEnable = !m_isEnable; - SML_LigthsSetEnable(m_idLight, m_isEnable); + SLight_SetEnable(m_idLight, m_isEnable); } void CLightDirectional::onSync() { BaseClass::onSync(); - if (SML_LigthsGetEnable(m_idLight) != m_isEnable) - SML_LigthsSetEnable(m_idLight, m_isEnable); + if (SLight_GetEnable(m_idLight) != m_isEnable) + SLight_SetEnable(m_idLight, m_isEnable); static float3 vec; - SML_LigthsGetPos(m_idLight, &vec, false); + SLight_GetPos(m_idLight, &vec, false); if (vec.x != m_vPosition.x || vec.y != m_vPosition.y || vec.z != m_vPosition.z) - SML_LigthsSetPos(m_idLight, &(float3)m_vPosition, false); + SLight_SetPos(m_idLight, &(float3)m_vPosition, false); - SML_LigthsSetColor(m_idLight, &(float3)m_vColor); + SLight_SetColor(m_idLight, &(float3)m_vColor); - if (SML_LigthsGetDist(m_idLight) != m_fDist) + if (SLight_GetDist(m_idLight) != m_fDist) { - SML_LigthsSetDist(m_idLight, m_fDist, true); + SLight_SetDist(m_idLight, m_fDist, true); m_fShadowDist = m_fDist; } - if (SML_LigthsGetShadowLocalFar(m_idLight) != m_fShadowDist) - SML_LigthsSetShadowLocalFar(m_idLight, m_fShadowDist); + if (SLight_GetShadowLocalFar(m_idLight) != m_fShadowDist) + SLight_SetShadowLocalFar(m_idLight, m_fShadowDist); - if (SML_LigthsGetTypeShadowed(m_idLight) != m_iShadowType) - SML_LigthsSetTypeShadowed(m_idLight, (LTYPE_SHADOW)m_iShadowType); + if (SLight_GetTypeShadowed(m_idLight) != m_iShadowType) + SLight_SetTypeShadowed(m_idLight, (LTYPE_SHADOW)m_iShadowType); static SMQuaternion curr_rot; - SML_LigthsGetOrient(m_idLight, &curr_rot); + SLight_GetOrient(m_idLight, &curr_rot); if (curr_rot.x != m_vOrientation.x || curr_rot.y != m_vOrientation.y || curr_rot.z != m_vOrientation.z || curr_rot.w != m_vOrientation.w) - SML_LigthsSetOrient(m_idLight, &m_vOrientation); + SLight_SetOrient(m_idLight, &m_vOrientation); - if (SML_LigthsGetAngle(m_idLight) != m_fAngle) - SML_LigthsSetAngle(m_idLight, m_fAngle); + if (SLight_GetAngle(m_idLight) != m_fAngle) + SLight_SetAngle(m_idLight, m_fAngle); - if (SML_LigthsGetTopRadius(m_idLight) != m_fRadiusTop) - SML_LigthsSetTopRadius(m_idLight, m_fRadiusTop); + if (SLight_GetTopRadius(m_idLight) != m_fRadiusTop) + SLight_SetTopRadius(m_idLight, m_fRadiusTop); } diff --git a/source/game/LightPoint.cpp b/source/game/LightPoint.cpp index 8e7ea413ac59cce38633355c46ab9fd500047bad..e7bca950aa116887985369481f4a60ee9eb5b6b2 100644 --- a/source/game/LightPoint.cpp +++ b/source/game/LightPoint.cpp @@ -6,7 +6,7 @@ See the license in LICENSE #include "LightPoint.h" -#include +#include /*! \skydocent light_point Точечный источник света @@ -50,46 +50,46 @@ BaseClass(pMgr) m_fDist = 10; m_fShadowDist = m_fDist; m_iShadowType = 1; - m_idLight = SML_LigthsCreatePoint(&float3(0, 0, 0), m_fDist, &(float3)m_vColor, false, true); + m_idLight = SLight_CreatePoint(&float3(0, 0, 0), m_fDist, &(float3)m_vColor, false, true); } CLightPoint::~CLightPoint() { - SML_LigthsDeleteLight(m_idLight); + SLight_DeleteLight(m_idLight); } void CLightPoint::toggleEnable() { m_isEnable = !m_isEnable; - SML_LigthsSetEnable(m_idLight, m_isEnable); + SLight_SetEnable(m_idLight, m_isEnable); } void CLightPoint::onSync() { BaseClass::onSync(); - if (SML_LigthsGetEnable(m_idLight) != m_isEnable) - SML_LigthsSetEnable(m_idLight, m_isEnable); + if (SLight_GetEnable(m_idLight) != m_isEnable) + SLight_SetEnable(m_idLight, m_isEnable); static float3 vec; - SML_LigthsGetPos(m_idLight, &vec, false); + SLight_GetPos(m_idLight, &vec, false); if (vec.x != m_vPosition.x || vec.y != m_vPosition.y || vec.z != m_vPosition.z) - SML_LigthsSetPos(m_idLight, &(float3)m_vPosition, false); + SLight_SetPos(m_idLight, &(float3)m_vPosition, false); - SML_LigthsSetColor(m_idLight, &(float3)m_vColor); + SLight_SetColor(m_idLight, &(float3)m_vColor); - if (SML_LigthsGetDist(m_idLight) != m_fDist) + if (SLight_GetDist(m_idLight) != m_fDist) { - SML_LigthsSetDist(m_idLight, m_fDist, true); + SLight_SetDist(m_idLight, m_fDist, true); m_fShadowDist = m_fDist; } - if (SML_LigthsGetShadowLocalFar(m_idLight) != m_fShadowDist) - SML_LigthsSetShadowLocalFar(m_idLight, m_fShadowDist); + if (SLight_GetShadowLocalFar(m_idLight) != m_fShadowDist) + SLight_SetShadowLocalFar(m_idLight, m_fShadowDist); - if (SML_LigthsGetTypeShadowed(m_idLight) != m_iShadowType) - SML_LigthsSetTypeShadowed(m_idLight, (LTYPE_SHADOW)m_iShadowType); + if (SLight_GetTypeShadowed(m_idLight) != m_iShadowType) + SLight_SetTypeShadowed(m_idLight, (LTYPE_SHADOW)m_iShadowType); } diff --git a/source/game/Player.cpp b/source/game/Player.cpp index f96411a951838d63f31bb770de7c3ea41039ca9f..745a1e80de205ffb89f32233344a74cf35ba3593 100644 --- a/source/game/Player.cpp +++ b/source/game/Player.cpp @@ -5,7 +5,7 @@ See the license in LICENSE ***********************************************************/ #include -#include +#include #include "Player.h" #include "LightDirectional.h" #include "BaseTool.h" diff --git a/source/game/sxgame_dll.cpp b/source/game/sxgame_dll.cpp index aca0cdfeb56ef3ed1cd3438a2caf07ec87c57899..aa069d513f8f624d68fa88f8ffcff1a4df0a51e9 100644 --- a/source/game/sxgame_dll.cpp +++ b/source/game/sxgame_dll.cpp @@ -27,7 +27,7 @@ See the license in LICENSE # pragma comment(lib, "sxanim_d.lib") # pragma comment(lib, "sxparticles_d.lib") # pragma comment(lib, "sxscore_d.lib") -//# pragma comment(lib, "sxpp_d.lib") +# pragma comment(lib, "sxmtrl_d.lib") # pragma comment(lib, "sxaigrid_d.lib") # pragma comment(lib, "sxgeom_d.lib") # pragma comment(lib, "sxlevel_d.lib") @@ -40,7 +40,7 @@ See the license in LICENSE # pragma comment(lib, "sxanim.lib") # pragma comment(lib, "sxparticles.lib") # pragma comment(lib, "sxscore.lib") -//# pragma comment(lib, "sxpp.lib") +# pragma comment(lib, "sxmtrl.lib") # pragma comment(lib, "sxaigrid.lib") # pragma comment(lib, "sxgeom.lib") # pragma comment(lib, "sxlevel.lib") diff --git a/source/gcore/LoaderTextures.cpp b/source/gcore/LoaderTextures.cpp index f37207e124c8104cadd4938776c58377f1d08a05..f790266dde2e1450fd9bec8591140809cdb430cf 100644 --- a/source/gcore/LoaderTextures.cpp +++ b/source/gcore/LoaderTextures.cpp @@ -127,7 +127,7 @@ ID } } - if(!IsTruePath) + if (!IsTruePath || (StrFindI(name, ":") >= 0 || StrFindI(name, "/") >= 0 || StrFindI(name, "\\") >= 0)) { LibReport(REPORT_MSG_LEVEL_ERROR, "%s - wrong texture name [%s]!!!", GEN_MSG_LOCATION, name); } diff --git a/source/gcore/gcore_data.cpp b/source/gcore/gcore_data.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4046d7858835c50d74fc68e6e285a00ff2753449 --- /dev/null +++ b/source/gcore/gcore_data.cpp @@ -0,0 +1,56 @@ + +#include "gcore_data.h" + +namespace gcore_data +{ + namespace rt_id + { + ID idComLight = -1; + + ID idColorScene = -1; + ID idNormalScene = -1; + ID idParamsScene = -1; + ID idDepthScene = -1; + ID idDepthScene0 = -1; + ID idDepthScene1 = -1; + + ID idLightAmbientDiff = -1; + ID idLightSpecular = -1; + + Array aToneMaps; + Array aSurfToneMap; + int iCountArrToneMaps = 0; + + //** + + ID idAdaptLumCurr = -1; + ID idAdaptLumLast = -1; + + int iHowAdaptedLum = 0; + ID GetCurrAdaptedLum(){ if (iHowAdaptedLum == 0) return idAdaptLumCurr; else return idAdaptLumLast; }; + ID GetLastAdaptedLum(){ if (iHowAdaptedLum == 1) return idAdaptLumCurr; else return idAdaptLumLast; }; + void IncrAdaptedLum(){ if (iHowAdaptedLum >= 1) iHowAdaptedLum = 0; else iHowAdaptedLum = 1; }; + + //** + + ID idLigthCom = -1; + ID idLigthCom2 = -1; + ID idLigthCom3 = -1; + + ID idLigthComScaled = -1; + + float2 aHDRSampleOffsets[16]; + }; + + namespace vs_id + { + ID idScreenOut = -1; + }; + + namespace ps_id + { + ID idSampleLumIterative = -1; + ID idSampleLumInit = -1; + ID idCalcAdaptedLum = -1; + }; +}; \ No newline at end of file diff --git a/source/gcore/gcore_data.h b/source/gcore/gcore_data.h new file mode 100644 index 0000000000000000000000000000000000000000..6551dfe913cc0583f4bb1b46c674c23f8e18c920 --- /dev/null +++ b/source/gcore/gcore_data.h @@ -0,0 +1,64 @@ + +#ifndef __GCORE_DATA +#define __GCORE_DATA + +#include +#include +#include +#include + +namespace gcore_data +{ + namespace rt_id + { + extern ID idComLight; + + extern ID idColorScene; + extern ID idNormalScene; + extern ID idParamsScene; + extern ID idDepthScene; + extern ID idDepthScene0; + extern ID idDepthScene1; + + extern ID idLightAmbientDiff; + extern ID idLightSpecular; + + extern Array aToneMaps; + extern Array aSurfToneMap; + extern int iCountArrToneMaps; + + //** + + extern ID idAdaptLumCurr; + extern ID idAdaptLumLast; + + extern int iHowAdaptedLum; + extern ID GetCurrAdaptedLum(); + extern ID GetLastAdaptedLum(); + extern void IncrAdaptedLum(); + + //** + + extern ID idLigthCom; + extern ID idLigthCom2; + extern ID idLigthCom3; + + extern ID idLigthComScaled; + + extern float2 aHDRSampleOffsets[16]; + }; + + namespace vs_id + { + extern ID idScreenOut; + }; + + namespace ps_id + { + extern ID idSampleLumIterative; + extern ID idSampleLumInit; + extern ID idCalcAdaptedLum; + }; +}; + +#endif \ No newline at end of file diff --git a/source/gcore/gcore_utils.cpp b/source/gcore/gcore_utils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..54327d61b85e4b5844d94c64d0b242f8b27bfc7c --- /dev/null +++ b/source/gcore/gcore_utils.cpp @@ -0,0 +1,326 @@ + +/*********************************************************** +Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#include "gcore_utils.h" + +void InitDevice(HWND hWnd, int iWidth, int iHeight, bool isWindowed, DWORD dwFlags) +{ + g_pD3D9 = Direct3DCreate9(D3D_SDK_VERSION); + + if (!g_pD3D9) + { + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - none detected d3d", GEN_MSG_LOCATION); + return; + } + + D3DCAPS9 caps; + g_pD3D9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps); + + memset(&g_oD3DAPP, 0, sizeof(g_oD3DAPP)); + g_oD3DAPP.BackBufferWidth = iWidth; + g_oD3DAPP.BackBufferHeight = iHeight; + g_oD3DAPP.BackBufferFormat = D3DFMT_A8R8G8B8; + g_oD3DAPP.BackBufferCount = 1; + g_oD3DAPP.MultiSampleType = D3DMULTISAMPLE_NONE; + g_oD3DAPP.MultiSampleQuality = 0; + g_oD3DAPP.SwapEffect = D3DSWAPEFFECT_DISCARD; + g_oD3DAPP.hDeviceWindow = hWnd; + g_oD3DAPP.Windowed = isWindowed; + g_oD3DAPP.EnableAutoDepthStencil = true; + g_oD3DAPP.AutoDepthStencilFormat = D3DFMT_D24S8; + g_oD3DAPP.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL | dwFlags | D3DCREATE_MULTITHREADED; + g_oD3DAPP.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT; + g_oD3DAPP.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; + + if (FAILED(g_pD3D9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING | dwFlags | D3DCREATE_MULTITHREADED, &g_oD3DAPP, &g_pDXDevice))) + { + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - failed initialized d3d", GEN_MSG_LOCATION); + return; + } +} + +void InitFPStext() +{ + D3DXFONT_DESC LF; + ZeroMemory(&LF, sizeof(D3DXFONT_DESC)); + LF.Height = 14; + LF.Width = 7; + LF.Weight = 10; + LF.Italic = 0; + LF.CharSet = DEFAULT_CHARSET; + sprintf(LF.FaceName, "Courier New"); + + D3DXCreateFontIndirect(g_pDXDevice, &LF, &g_pFPStext); +} + +void InitFullScreenQuad() +{ + D3DVERTEXELEMENT9 oLayoutQuad[] = + { + { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, + { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 }, + D3DDECL_END() + }; + + D3DXCreateMesh(2, 4, D3DXMESH_MANAGED, oLayoutQuad, g_pDXDevice, &g_pScreenTexture); + + struct VERTEX_SCREEN_TEXTURE { float x, y, z, tx, ty, tz; }; + + const float fOffsetPixelX = 1.0f / float(g_oD3DAPP.BackBufferWidth); + const float fOffsetPixelY = 1.0f / float(g_oD3DAPP.BackBufferHeight); + + VERTEX_SCREEN_TEXTURE aVertices[] = + { + { -1.0f - fOffsetPixelX, -1.0f + fOffsetPixelY, 1.0f, 0.0f, 1.0f, 0 }, + { -1.0f - fOffsetPixelX, 1.0f + fOffsetPixelY, 1.0f, 0.0f, 0.0f, 1 }, + { 1.0f - fOffsetPixelX, 1.0f + fOffsetPixelY, 1.0f, 1.0f, 0.0f, 2 }, + { 1.0f - fOffsetPixelX, -1.0f + fOffsetPixelY, 1.0f, 1.0f, 1.0f, 3 }, + }; + + void * pVertices; + if (!FAILED(g_pScreenTexture->LockVertexBuffer(0, (void**)&pVertices))) + { + memcpy(pVertices, aVertices, sizeof(aVertices)); + g_pScreenTexture->UnlockVertexBuffer(); + } + + WORD *pIndeces = 0; + g_pScreenTexture->LockIndexBuffer(0, (void**)&pIndeces); + pIndeces[0] = 0; pIndeces[1] = 1; pIndeces[2] = 2; + pIndeces[3] = 0; pIndeces[4] = 2; pIndeces[5] = 3; + g_pScreenTexture->UnlockIndexBuffer(); +} + +void InitArrModes() +{ + // + DEVMODE oDevMode; + int iNum = 0; + while (EnumDisplaySettings(NULL, iNum, &oDevMode)) + { + iNum++; + if (oDevMode.dmBitsPerPel >= 32 && oDevMode.dmPelsWidth >= 800 && oDevMode.dmPelsHeight >= 600) + { + bool isUnic = true; + for (int i = 0, il = g_aModes.size(); i < il; ++i) + { + if (g_aModes[i].dmPelsWidth == oDevMode.dmPelsWidth && g_aModes[i].dmPelsHeight == oDevMode.dmPelsHeight) + { + isUnic = false; + break; + } + } + + if (isUnic) + g_aModes.push_back(oDevMode); + } + } +} + +void InitRT4Gbuffer() +{ + const int *r_win_width = GET_PCVAR_INT("r_win_width"); + const int *r_win_height = GET_PCVAR_INT("r_win_height"); + + float tmpcoefsizert = 1; + float2_t tmp_sizert = float2_t(float(*r_win_width) * tmpcoefsizert, (*r_win_height) * tmpcoefsizert); + + // () + gcore_data::rt_id::idColorScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, "ds_color", tmpcoefsizert); + // + + gcore_data::rt_id::idNormalScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8/*D3DFMT_A2R10G10B10*/, D3DPOOL_DEFAULT, "ds_normal", tmpcoefsizert); + // + gcore_data::rt_id::idParamsScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, "ds_param", tmpcoefsizert); + + gcore_data::rt_id::idDepthScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "ds_depth", tmpcoefsizert); + gcore_data::rt_id::idDepthScene0 = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "ds_depth_0", tmpcoefsizert); + gcore_data::rt_id::idDepthScene1 = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "ds_depth_1", tmpcoefsizert); + + gcore_data::rt_id::idLightAmbientDiff = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, "ds_ambient", tmpcoefsizert); + gcore_data::rt_id::idLightSpecular = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R16F, D3DPOOL_DEFAULT, "ds_specdiff", tmpcoefsizert); + + + gcore_data::rt_id::aToneMaps.clear(); + gcore_data::rt_id::aSurfToneMap.clear(); + + char szNameRT[64]; + int tmpcount = 0; + while (true) + { + int tmpsize = 1 << (2 * tmpcount); + if (tmpsize >= float(*r_win_width)*0.25 || tmpsize > (*r_win_height)*0.25) + break; + + sprintf(szNameRT, "tone_map_%dx%d", tmpsize, tmpsize); + gcore_data::rt_id::aToneMaps[tmpcount] = SGCore_RTAdd(tmpsize, tmpsize, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R16F, D3DPOOL_DEFAULT, szNameRT, 0); + gcore_data::rt_id::aSurfToneMap[tmpcount] = 0; + ++tmpcount; + } + gcore_data::rt_id::iCountArrToneMaps = tmpcount; + + gcore_data::rt_id::idAdaptLumCurr = SGCore_RTAdd(1, 1, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R16F, D3DPOOL_DEFAULT, "adapted_lum_curr", 0); + gcore_data::rt_id::idAdaptLumLast = SGCore_RTAdd(1, 1, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R16F, D3DPOOL_DEFAULT, "adapted_lum_last", 0); + + gcore_data::rt_id::idLigthCom = SGCore_RTAdd(*r_win_width, *r_win_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, "ds_lightcom", 1); + gcore_data::rt_id::idLigthCom2 = SGCore_RTAdd(*r_win_width, *r_win_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, "ds_lightcom2", 1); + gcore_data::rt_id::idLigthCom3 = SGCore_RTAdd(*r_win_width, *r_win_height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, "ds_lightcom3", 1); + + gcore_data::rt_id::idLigthComScaled = SGCore_RTAdd(float(*r_win_width)*0.25f, float(*r_win_height)*0.25f, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, "ds_lightcomscaled", 0.25); + + + gcore_data::ps_id::idCalcAdaptedLum = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pptm_calc_adapted_lum.ps", "pptm_calc_adapted_lum.ps", SHADER_CHECKDOUBLE_PATH); + gcore_data::ps_id::idSampleLumInit = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pptm_lum_init.ps", "pptm_lum_init.ps", SHADER_CHECKDOUBLE_PATH); + gcore_data::ps_id::idSampleLumIterative = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pptm_lum_iterative.ps", "pptm_lum_iterative.ps", SHADER_CHECKDOUBLE_PATH); +} + +void LoadShaders() +{ + gcore_data::vs_id::idScreenOut = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_quad_render.vs", "pp_quad_render.vs", SHADER_CHECKDOUBLE_PATH); + //MLSet::IDsShaders::PS::ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_quad_render.ps", "pp_quad_render.ps", SHADER_CHECKDOUBLE_PATH); +} + +void ToneMappingGetArrDownScale4x4(int iWidth, int iHeight, float2 aDS[]) +{ + if (aDS == 0) + return; + + float tU = 1.0f / float(iWidth); + float tV = 1.0f / float(iHeight); + + int index = 0; + + for (int y = 0; y < 4; ++y) + { + for (int x = 0; x < 4; ++x) + { + aDS[index].x = (x - 1.5f) * tU; + aDS[index].y = (y - 1.5f) * tV; + + ++index; + } + } +} + +void ToneMappingCom(DWORD timeDelta, float fFactorAdapted) +{ + static const int *r_win_width = GET_PCVAR_INT("r_win_width"); + static const int *r_win_height = GET_PCVAR_INT("r_win_height"); + + ToneMappingGetArrDownScale4x4(*r_win_width, *r_win_height, gcore_data::rt_id::aHDRSampleOffsets); + + LPDIRECT3DSURFACE9 SurfSceneScale, BackBuf; + + SGCore_RTGetTexture(gcore_data::rt_id::idLigthComScaled)->GetSurfaceLevel(0, &SurfSceneScale); + + g_pDXDevice->GetRenderTarget(0, &BackBuf); + g_pDXDevice->SetRenderTarget(0, SurfSceneScale); + + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gcore_data::vs_id::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumIterative); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumIterative, "g_aOffsets", &(gcore_data::rt_id::aHDRSampleOffsets)); + + g_pDXDevice->SetTexture(0, SGCore_RTGetTexture(gcore_data::rt_id::idLigthCom)); + SGCore_ScreenQuadDraw(); + + SGCore_ShaderUnBind(); + + mem_release(SurfSceneScale); + + g_pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED); + int CurrTexture = gcore_data::rt_id::iCountArrToneMaps - 1; + + for (int i = 0; i < gcore_data::rt_id::iCountArrToneMaps; i++) + { + IDirect3DTexture9* tmptex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[i]); + IDirect3DSurface9* tmpsurf = gcore_data::rt_id::aSurfToneMap[i]; + SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[i])->GetSurfaceLevel(0, &gcore_data::rt_id::aSurfToneMap[i]); + int qwert = 0; + } + + D3DSURFACE_DESC desc; + SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[CurrTexture])->GetLevelDesc(0, &desc); + + ToneMappingGetArrDownScale4x4(desc.Width, desc.Height, gcore_data::rt_id::aHDRSampleOffsets); + + g_pDXDevice->SetRenderTarget(0, gcore_data::rt_id::aSurfToneMap[CurrTexture]); + g_pDXDevice->SetTexture(0, SGCore_RTGetTexture(gcore_data::rt_id::idLigthComScaled)); + g_pDXDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); + g_pDXDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); + g_pDXDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); + g_pDXDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); + + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gcore_data::vs_id::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumInit); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumInit, "g_aOffsets", &(gcore_data::rt_id::aHDRSampleOffsets)); + + SGCore_ScreenQuadDraw(); + + SGCore_ShaderUnBind(); + mem_release(gcore_data::rt_id::aSurfToneMap[CurrTexture]); + + --CurrTexture; + + + + while (CurrTexture >= 0) + { + SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[CurrTexture + 1])->GetLevelDesc(0, &desc); + ToneMappingGetArrDownScale4x4(desc.Width, desc.Height, gcore_data::rt_id::aHDRSampleOffsets); + + g_pDXDevice->SetRenderTarget(0, gcore_data::rt_id::aSurfToneMap[CurrTexture]); + g_pDXDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); + g_pDXDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); + + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gcore_data::vs_id::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumIterative); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumIterative, "g_aOffsets", &(gcore_data::rt_id::aHDRSampleOffsets)); + + g_pDXDevice->SetTexture(0, SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[CurrTexture + 1])); + SGCore_ScreenQuadDraw(); + + SGCore_ShaderUnBind(); + CurrTexture--; + } + + IDirect3DTexture9* tmptex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[3]); + + for (int i = 0; i < gcore_data::rt_id::iCountArrToneMaps - 1; i++) + { + IDirect3DSurface9* tmpsurf = gcore_data::rt_id::aSurfToneMap[i]; + mem_release(gcore_data::rt_id::aSurfToneMap[i]); + } + + tmptex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[3]); + + gcore_data::rt_id::IncrAdaptedLum(); + LPDIRECT3DSURFACE9 SurfAdaptedLum = NULL; + SGCore_RTGetTexture(gcore_data::rt_id::GetCurrAdaptedLum())->GetSurfaceLevel(0, &SurfAdaptedLum); + + g_pDXDevice->SetRenderTarget(0, SurfAdaptedLum); + g_pDXDevice->SetTexture(0, SGCore_RTGetTexture(gcore_data::rt_id::GetLastAdaptedLum())); + g_pDXDevice->SetTexture(1, SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[0])); + g_pDXDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); + g_pDXDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); + g_pDXDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_POINT); + g_pDXDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_POINT); + + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gcore_data::vs_id::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gcore_data::ps_id::idCalcAdaptedLum); + + float ElapsedTime = float(timeDelta) * 0.001f * (fFactorAdapted * 1000.f); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gcore_data::ps_id::idCalcAdaptedLum, "g_fElapsedTime", &(ElapsedTime)); + + SGCore_ScreenQuadDraw(); + + SGCore_ShaderUnBind(); + mem_release(SurfAdaptedLum); + + g_pDXDevice->SetRenderTarget(0, BackBuf); + mem_release(BackBuf); + + g_pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); + +} \ No newline at end of file diff --git a/source/gcore/gcore_utils.h b/source/gcore/gcore_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..d6351721b5f3851e7f3d3bb1e8f67dd160d3aebe --- /dev/null +++ b/source/gcore/gcore_utils.h @@ -0,0 +1,53 @@ + +/*********************************************************** +Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#ifndef __UTILS_H +#define __UTILS_H + +#include +#include +#include +#include + +#include +#include + +//########################################################################## + +extern IDirect3DDevice9 *g_pDXDevice; +extern D3DPRESENT_PARAMETERS g_oD3DAPP; +extern IDirect3D9 *g_pD3D9; +extern ID3DXFont *g_pFPStext; +extern Array g_aModes; +extern ID3DXMesh *g_pScreenTexture; + +//########################################################################## + +//! +void InitDevice(HWND hWnd, int iWidth, int iHeight, bool isWindowed, DWORD dwFlags); + +//! +void InitFPStext(); + +//! +void InitFullScreenQuad(); + +//! +void InitArrModes(); + +//! +void InitRT4Gbuffer(); + +//! +void LoadShaders(); + +//! tone mapping +void ToneMappingGetArrDownScale4x4(int iWidth, int iHeight, float2 aDS[]); + +//! tone mapping +void ToneMappingCom(DWORD timeDelta, float fFactorAdapted); + +#endif \ No newline at end of file diff --git a/source/gcore/oc.cpp b/source/gcore/oc.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d3be0b881f65595abfb93786a60665bea98d615b --- /dev/null +++ b/source/gcore/oc.cpp @@ -0,0 +1,632 @@ + +/*********************************************************** +Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#include "oc.h" + +void SwapFloat3(float3 &vA, float3 &vB) +{ + float3 vV; + vV = vA; + vA = vB; + vB = vV; +} + +void TriGetSphere(const float3 &vA, const float3 &vB, const float3 &vC, float &fRadius, float2 &vCenter) +{ + float x12 = vA.x - vB.x; + float x23 = vB.x - vC.x; + float x31 = vC.x - vA.x; + + float y12 = vA.y - vB.y; + float y23 = vB.y - vC.y; + float y31 = vC.y - vA.y; + + float z1 = (vA.x * vA.x) + (vA.y * vA.y); + float z2 = (vB.x * vB.x) + (vB.y * vB.y); + float z3 = (vC.x * vC.x) + (vC.y * vC.y); + + float zx = y12 * z3 + y23 * z1 + y31 * z2; + float zy = x12 * z3 + x23 * z1 + x31 * z2; + float z = x12 * y31 - y12 * x31; + + vCenter.x = -(zx / (2 * z)); + vCenter.y = zy / (2 * z); + + fRadius = sqrt(pow(vA.x - vCenter.x, 2) + (vA.y - vCenter.y, 2)); +} + +void QuadGetSphere(const float2 &vMin, const float2 &vMax, float &fRadius, float2 &vCenter) +{ + vCenter = (vMin + vMax) / 2; + + fRadius = SMVector2Length(vCenter - vMin); +} + +//########################################################################## + +COcclusionCulling::COcclusionCulling() +{ + m_isEnable = true; + + m_pFrustum = 0; + m_iCountFC = 0; + m_iCountFCfail = 0; + + m_iWidth = m_iHeight = m_iCountPixels = 0; + + m_pSurfDepthBuffer[0] = m_pSurfDepthBuffer[1] = m_pSurfDepthBuffer[2]; + + m_pArrDepthBuffer = 0; + m_pArrDepthBuffer = 0; + m_pArrWorldPos = 0; + m_pArrDepthBufferReProjection = 0; + m_pArrDepthBufferRasterize = 0; + + m_aRTdepth[0] = -1; + m_aRTdepth[1] = -1; + + m_idVS_ScreenOut = -1; + m_idPS_ScreenOut = -1; + m_idPS_FindMax9 = -1; + + m_fBiasDepth = 0.0001f; + + m_iCurrRTdepth = 0; +} + +COcclusionCulling::~COcclusionCulling() +{ + mem_release(m_pSurfDepthBuffer[0]); + mem_release(m_pSurfDepthBuffer[1]); + mem_release(m_pSurfDepthBuffer[2]); + mem_delete_a(m_pArrDepthBuffer); + mem_delete_a(m_pArrDepthBufferReProjection); + mem_delete_a(m_pArrWorldPos); + mem_delete_a(m_pArrDepthBufferRasterize); +} + +void COcclusionCulling::init(int iWidth, int iHeight) +{ + m_iWidth = float(iWidth * OC_SIZE_COEF); + m_iHeight = float(iHeight * OC_SIZE_COEF); + m_iCountPixels = m_iWidth * m_iHeight; + + g_pDXDevice->CreateOffscreenPlainSurface(m_iWidth, m_iHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &m_pSurfDepthBuffer[0], 0); + g_pDXDevice->CreateOffscreenPlainSurface(m_iWidth, m_iHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &m_pSurfDepthBuffer[1], 0); + g_pDXDevice->CreateOffscreenPlainSurface(m_iWidth, m_iHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &m_pSurfDepthBuffer[2], 0); + + m_pArrDepthBuffer = new float[m_iCountPixels + 1]; + m_pArrWorldPos = new float4[m_iCountPixels + 1]; + m_pArrDepthBufferReProjection = new float[m_iCountPixels + 1]; + m_pArrDepthBufferRasterize = new float[m_iCountPixels + 1]; + + m_aRTdepth[0] = SGCore_RTAdd(m_iWidth, m_iHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "depth_oc", 0.25f); + m_aRTdepth[1] = SGCore_RTAdd(m_iWidth, m_iHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "depth_oc2", 0.25f); + + m_idVS_ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_quad_render.vs", "pp_quad_render.vs", SHADER_CHECKDOUBLE_PATH); + m_idPS_ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_quad_render.ps", "pp_quad_render.ps", SHADER_CHECKDOUBLE_PATH); + m_idPS_FindMax9 = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_depth_find_max9.ps", "pp_depth_find_max9.ps", SHADER_CHECKDOUBLE_NAME); +} + +void COcclusionCulling::onLostDevice() +{ + mem_release(m_pSurfDepthBuffer[0]); + mem_release(m_pSurfDepthBuffer[1]); + mem_release(m_pSurfDepthBuffer[2]); + + mem_delete_a(m_pArrDepthBuffer); + mem_delete_a(m_pArrDepthBufferReProjection); + mem_delete_a(m_pArrWorldPos); + mem_delete_a(m_pArrDepthBufferRasterize); +} + +void COcclusionCulling::onResetDevice(int iWidth, int iHeight) +{ + m_iWidth = float(iWidth * OC_SIZE_COEF); + m_iHeight = float(iHeight * OC_SIZE_COEF); + m_iCountPixels = m_iWidth * m_iHeight; + + g_pDXDevice->CreateOffscreenPlainSurface(m_iWidth, m_iHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &m_pSurfDepthBuffer[0], 0); + g_pDXDevice->CreateOffscreenPlainSurface(m_iWidth, m_iHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &m_pSurfDepthBuffer[1], 0); + g_pDXDevice->CreateOffscreenPlainSurface(m_iWidth, m_iHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &m_pSurfDepthBuffer[2], 0); + + m_pArrDepthBuffer = new float[m_iCountPixels + 1]; + m_pArrWorldPos = new float4[m_iCountPixels + 1]; + m_pArrDepthBufferReProjection = new float[m_iCountPixels + 1]; + m_pArrDepthBufferRasterize = new float[m_iCountPixels + 1]; +} + + +void COcclusionCulling::setEnable(bool isEnable) +{ + m_isEnable = isEnable; +} + +bool COcclusionCulling::getEnable() +{ + return m_isEnable; +} + +void COcclusionCulling::update(ID idDepthMap, const IFrustum *pFrustum) +{ + if (!m_isEnable) + return; + + m_pFrustum = pFrustum; + m_iCountFC = 0; + m_iCountFCfail = 0; + + static const float *r_near = GET_PCVAR_FLOAT("r_near"); + static const float *r_far = GET_PCVAR_FLOAT("r_far"); + + // - + if (!r_near || !r_far) + { + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - cvar r_near or r_far is not found!", GEN_MSG_LOCATION); + return; + } + + static const float *r_default_fov = GET_PCVAR_FLOAT("r_default_fov"); + + // fov - + if (!r_default_fov) + { + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - cvar r_default_fov is not found!", GEN_MSG_LOCATION); + return; + } + + m_fBiasDepth = 1.f / (*r_far); + + IDirect3DTexture9 *pTexDepth = SGCore_RTGetTexture(idDepthMap); + IDirect3DTexture9 *pTexDepthOC = SGCore_RTGetTexture(m_aRTdepth[m_iCurrRTdepth]); + + // + g_pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + g_pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + g_pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + g_pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + LPDIRECT3DSURFACE9 RenderSurf2, BackBuf2; + + pTexDepthOC->GetSurfaceLevel(0, &RenderSurf2); + g_pDXDevice->GetRenderTarget(0, &BackBuf2); + g_pDXDevice->SetRenderTarget(0, RenderSurf2); + + SGCore_SetSamplerFilter(0, D3DTEXF_NONE); + SGCore_SetSamplerAddress(0, D3DTADDRESS_CLAMP); + + g_pDXDevice->SetTexture(0, pTexDepth); + + SGCore_ShaderBind(SHADER_TYPE_VERTEX, m_idVS_ScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, m_idPS_FindMax9); + + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, m_idPS_FindMax9, "g_vPixelSize", (&float2(1.f / float(g_oD3DAPP.BackBufferWidth), 1.f / float(g_oD3DAPP.BackBufferHeight)))); + + SGCore_ScreenQuadDraw(); + + SGCore_ShaderUnBind(); + + g_pDXDevice->SetRenderTarget(0, BackBuf2); + + mem_release(RenderSurf2); + mem_release(BackBuf2); + + //********************************************************************** + + // + LPDIRECT3DSURFACE9 pDepthSurf; + + int iCurrOld = 1 - m_iCurrRTdepth; + + pTexDepthOC = SGCore_RTGetTexture(m_aRTdepth[m_iCurrRTdepth]); + + pTexDepthOC->GetSurfaceLevel(0, &pDepthSurf); + g_pDXDevice->GetRenderTargetData(pDepthSurf, m_pSurfDepthBuffer[m_iCurrRTdepth]); + + D3DLOCKED_RECT srect; + m_pSurfDepthBuffer[iCurrOld]->LockRect(&srect, 0, D3DLOCK_READONLY | D3DLOCK_DONOTWAIT); + + memcpy(m_pArrDepthBuffer, srect.pBits, sizeof(float)* m_iCountPixels); + m_pSurfDepthBuffer[iCurrOld]->UnlockRect(); + + mem_release(pDepthSurf); + + //********************************************************************** + + float fPosX = 0, fPosY = 0; + + float4 vWorldPos; + + float4x4 mView, mProjection; + Core_RMatrixGet(G_RI_MATRIX_OBSERVER_VIEW, &mView); + Core_RMatrixGet(G_RI_MATRIX_OBSERVER_PROJ, &mProjection); + + float4x4 mViewProj = m_mOldView * m_mOldProj;// = mView * mProjection; + float fD = 0.f; + float4x4 mInvVP = SMMatrixInverse(&fD, mViewProj); + + float3 vObserverPos; + Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vObserverPos); + + float fTanHalfFOV = tan((*r_default_fov) * 0.5f); + float fAspectRatio = float(m_iWidth) / float(m_iHeight); + float fFarY = fTanHalfFOV * (*r_far); + float fFarX = fFarY * fAspectRatio; + + float4 vEyeRay, vWorldRay; + float4x4 mInvView = SMMatrixInverse(&fD, m_mOldView); + + float4 aWorldRays[4]; + aWorldRays[0] = SMVector4Transform(float4(-1.f * fFarX, -1.f * fFarY, (*r_far), 0.f), mInvView); + aWorldRays[1] = SMVector4Transform(float4(1.f * fFarX, -1.f * fFarY, (*r_far), 0.f), mInvView); + aWorldRays[2] = SMVector4Transform(float4(1.f * fFarX, 1.f * fFarY, (*r_far), 0.f), mInvView); + aWorldRays[3] = SMVector4Transform(float4(-1.f * fFarX, 1.f * fFarY, (*r_far), 0.f), mInvView); + + float4 vWorldRay0, vWorldRay1; + + for (int x = 0; x < m_iWidth; ++x) + { + vWorldRay0 = SMVectorLerp(aWorldRays[0], aWorldRays[1], float(x) / m_iWidth); + vWorldRay1 = SMVectorLerp(aWorldRays[3], aWorldRays[2], float(x) / m_iWidth); + for (int y = 0; y < m_iHeight; ++y) + { + int iPosPixel = (y * m_iWidth) + x; + vWorldRay = SMVectorLerp(vWorldRay1, vWorldRay0, float(y) / m_iHeight); + vWorldPos = vObserverPos + vWorldRay * m_pArrDepthBuffer[iPosPixel]; + vWorldPos.w = 1.f; + m_pArrWorldPos[iPosPixel] = vWorldPos; + } + } + + m_mOldView = mView; + m_mOldProj = mProjection; + + ++m_iCurrRTdepth; + + if (m_iCurrRTdepth >= 2) + m_iCurrRTdepth = 0; + + + /*if (GetKeyState('M')) + { + m_pSurfDepthBuffer[2]->LockRect(&srect, 0, D3DLOCK_READONLY); + + memcpy(srect.pBits, m_pArrDepthBuffer, sizeof(float)* m_iCountPixels); + m_pSurfDepthBuffer[2]->UnlockRect(); + + D3DXSaveSurfaceToFile("C:/1/m_pSurfDepthBuffer.jpg", D3DXIFF_JPG, m_pSurfDepthBuffer[2], NULL, NULL); + }*/ +} + + +void COcclusionCulling::reprojection() +{ + if (!m_isEnable) + return; + + static const float *r_near = GET_PCVAR_FLOAT("r_near"); + static const float *r_far = GET_PCVAR_FLOAT("r_far"); + + if (!r_near || !r_far) + { + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - cvar r_near or r_far is not found!", GEN_MSG_LOCATION); + return; + } + + float4x4 mView, mProjection; + Core_RMatrixGet(G_RI_MATRIX_OBSERVER_VIEW, &mView); + Core_RMatrixGet(G_RI_MATRIX_OBSERVER_PROJ, &mProjection); + + float4x4 mViewProj = mView * mProjection; + + float4 vNewPos; + + for (int i = 0; i < m_iCountPixels; ++i) + { + m_pArrDepthBufferReProjection[i] = 1.f; + m_pArrDepthBufferRasterize[i] = 1.f; + } + + float3 vObserverPos; + Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vObserverPos); + + float2 vNewPos2; + + // , screen-space + for (int i = 0; i < m_iCountPixels; ++i) + { + vNewPos = SMVector4Transform(m_pArrWorldPos[i], mViewProj); + + vNewPos.x /= abs(vNewPos.w); + vNewPos.y /= abs(vNewPos.w); + vNewPos.z = (vNewPos.z + (*r_near)) / (*r_far); + + vNewPos.x = vNewPos.x * 0.5f + 0.5f; + vNewPos.y = (vNewPos.y * (-0.5f) + 0.5f); + + // , + + vNewPos2.x = float(int(vNewPos.x * 10000.f) / 10000.f); + vNewPos2.y = float(int(vNewPos.y * 10000.f) / 10000.f); + + if (vNewPos2.x == 0.f || vNewPos2.x == 1.f) + vNewPos.x = vNewPos2.x; + + if (vNewPos2.y == 0.f || vNewPos2.y == 1.f) + vNewPos.y = vNewPos2.y; + + //****************************************************************** + + if ((vNewPos.x <= 1.f && vNewPos.x >= 0.f) && (vNewPos.y <= 1.f && vNewPos.y >= 0.f)) + { + int x = floor(vNewPos.x * float(m_iWidth) + 0.5f); + int y = floor(vNewPos.y * m_iHeight + 0.5f); + int iPosPixel = int(y * m_iWidth) + x; + + if (iPosPixel > m_iCountPixels) + int qwerty = 0; + else + { + // , + if (m_pArrDepthBufferReProjection[iPosPixel] >= 1.f || vNewPos.z > m_pArrDepthBufferReProjection[iPosPixel]) + m_pArrDepthBufferReProjection[iPosPixel] = vNewPos.z; + } + } + } + + + /*if (GetKeyState('N')) + { + D3DLOCKED_RECT srect; + g_pOCsurfDepthBuffer[2]->LockRect(&srect, 0, D3DLOCK_READONLY); + + memcpy(srect.pBits, g_pOCarrDepthBufferReProjection, sizeof(float)* g_iOCcountPixels); + g_pOCsurfDepthBuffer[2]->UnlockRect(); + D3DXSaveSurfaceToFile("C:/1/g_pSurfDepthBufferOCreproj.jpg", D3DXIFF_JPG, g_pOCsurfDepthBuffer[2], NULL, NULL); + }*/ +} + +bool COcclusionCulling::comVisible(const float3 *pMax, const float3 *pMin) +{ + if (!pMax || !pMin) + { + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - min or max is null!", GEN_MSG_LOCATION); + return false; + } + + if (!m_isEnable) + return true; + + float3 vObserverPos; + Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vObserverPos); + + static const float *r_near = GET_PCVAR_FLOAT("r_near"); + static const float *r_far = GET_PCVAR_FLOAT("r_far"); + + if (!r_near || !r_far) + { + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - cvar r_near or r_far is not found!", GEN_MSG_LOCATION); + return false; + } + + float3 vMax, vMin; + vMax = *pMax; + vMin = *pMin; + + // xz + float3 vCenter = (vMin + vMax) * 0.5f; + float fRadius = SMVector3Length2(float3(vCenter.x, 0.f, vCenter.z) - float3(vMax.x, 0, vMax.z)); + + float fDist = SMVector3Length2(vObserverPos - vCenter); + + // xz + if (fDist <= fRadius) + return true; + + fDist -= fRadius; + + // , + if (fDist >= 0.f && fDist <= OC_DIST_NEAR_NOT_CULL*OC_DIST_NEAR_NOT_CULL) + return true; + + // , , + vMax += g_cvOCext; + vMin -= g_cvOCext; + + float4x4 mWorld, mView, mProjection; + Core_RMatrixGet(G_RI_MATRIX_WORLD, &mWorld); + Core_RMatrixGet(G_RI_MATRIX_OBSERVER_VIEW, &mView); + Core_RMatrixGet(G_RI_MATRIX_OBSERVER_PROJ, &mProjection); + + float4x4 mWVP = mWorld * mView *mProjection; + + + float4 aSSPoints[8]; + float4 aWPoints[8]; + aWPoints[0] = float4(vMax.x, vMax.y, vMax.z, 1.0f); + aWPoints[1] = float4(vMax.x, vMax.y, vMin.z, 1.0f); + aWPoints[2] = float4(vMax.x, vMin.y, vMax.z, 1.0f); + aWPoints[3] = float4(vMin.x, vMax.y, vMax.z, 1.0f); + aWPoints[4] = float4(vMax.x, vMin.y, vMin.z, 1.0f); + aWPoints[5] = float4(vMin.x, vMin.y, vMax.z, 1.0f); + aWPoints[6] = float4(vMin.x, vMax.y, vMin.z, 1.0f); + aWPoints[7] = float4(vMin.x, vMin.y, vMin.z, 1.0f); + + for (int i = 0; i < 8; ++i) + { + aSSPoints[i] = SMVector4Transform(aWPoints[i], mWVP); + + aSSPoints[i].x /= abs(aSSPoints[i].w); + aSSPoints[i].y /= abs(aSSPoints[i].w); + aSSPoints[i].z = ((aSSPoints[i].z + (*r_near)) / (*r_far));// *sign(aSSPoints[i].w); + + // + //float fLinearDepth = (*r_near) / ((*r_far) + (*r_near) - aPoints[i].w * ((*r_far) - (*r_near))); + + aSSPoints[i].x = aSSPoints[i].x * 0.5 + 0.5; + aSSPoints[i].y = aSSPoints[i].y * (-0.5) + 0.5; + + aSSPoints[i].x *= m_iWidth; + aSSPoints[i].y *= m_iHeight; + + aSSPoints[i].x = int(aSSPoints[i].x); + aSSPoints[i].y = int(aSSPoints[i].y); + } + + float2 vNearFar((*r_near), (*r_far)); + + bool isVisible = ( + (triFrustumCulling(aWPoints[7], aWPoints[6], aWPoints[1]) && triRasterize(aSSPoints[7], aSSPoints[6], aSSPoints[1], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[7], aWPoints[1], aWPoints[4]) && triRasterize(aSSPoints[7], aSSPoints[1], aSSPoints[4], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[0], aWPoints[5], aWPoints[2]) && triRasterize(aSSPoints[0], aSSPoints[5], aSSPoints[2], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[0], aWPoints[3], aWPoints[5]) && triRasterize(aSSPoints[0], aSSPoints[3], aSSPoints[5], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[0], aWPoints[1], aWPoints[3]) && triRasterize(aSSPoints[0], aSSPoints[1], aSSPoints[3], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[1], aWPoints[6], aWPoints[3]) && triRasterize(aSSPoints[1], aSSPoints[6], aSSPoints[3], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[5], aWPoints[4], aWPoints[2]) && triRasterize(aSSPoints[5], aSSPoints[4], aSSPoints[2], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[4], aWPoints[5], aWPoints[7]) && triRasterize(aSSPoints[4], aSSPoints[5], aSSPoints[7], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[0], aWPoints[2], aWPoints[1]) && triRasterize(aSSPoints[0], aSSPoints[2], aSSPoints[1], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[1], aWPoints[2], aWPoints[4]) && triRasterize(aSSPoints[1], aSSPoints[2], aSSPoints[4], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[6], aWPoints[5], aWPoints[3]) && triRasterize(aSSPoints[6], aSSPoints[5], aSSPoints[3], false, aSSPoints[0], vNearFar)) || + (triFrustumCulling(aWPoints[5], aWPoints[6], aWPoints[7]) && triRasterize(aSSPoints[5], aSSPoints[6], aSSPoints[7], false, aSSPoints[0], vNearFar)) + ); + + return isVisible; +} + + +bool COcclusionCulling::triFrustumCulling(const float3 &vA, const float3 &vB, const float3 &vC) +{ + /*if (GetAsyncKeyState('P')) + return true;*/ + + ++m_iCountFC; + + bool isVisible = (!m_pFrustum || m_pFrustum->polyInFrustum(&vA, &vB, &vC)); + + if (!isVisible) + ++m_iCountFCfail; + + return isVisible; +} + +bool COcclusionCulling::triRasterize(const float4 &vA, const float4 &vB, const float4 &vC, bool isRasterize, const float3 &vNormal2, const float2_t &vNearFar) +{ + if (vA.z < 0.f && vB.z < 0.f && vC.z < 0.f) + return false; + + float3 vNormal = SMVector3Normalize(SMVector3Cross(vC - vA, vB - vA)); + + float3 vPointA = vA; + float3 vPointB = vB; + float3 vPointC = vC; + + // D + float fD = -(vNormal.x * vPointA.x + vNormal.y * vPointA.y + vNormal.z * vPointA.z); + + /* + : -(N.x * x + N.y * y + D) / N.z + N - + x y - + */ + + // Y + if (vPointB.y < vPointA.y) + SwapFloat3(vPointA, vPointB); + + if (vPointC.y < vPointA.y) + SwapFloat3(vPointA, vPointC); + + if (vPointB.y > vPointC.y) + SwapFloat3(vPointB, vPointC); + + + bool isVisible = false; + + // , , + vPointA.y -= g_fOCextTriangle; + vPointC.y += g_fOCextTriangle; + + int iTotalHeight = vPointC.y - vPointA.y; + + if (iTotalHeight == 0) + return false; + + int iSegmentHeight = vPointB.y - vPointA.y + 1; + + if (iSegmentHeight == 0) + return false; + + int iStartY = clampf(vPointA.y, 0, m_iHeight - 1); + int iFinishY = clampf(vPointB.y, 0, m_iHeight - 1); + + for (int y = iStartY; y <= iFinishY; ++y) + { + float fA = (y - vPointA.y) / iTotalHeight; + float fB = (y - vPointA.y) / iSegmentHeight; + fA = vPointA.x + (vPointC.x - vPointA.x) * fA; + fB = vPointA.x + (vPointB.x - vPointA.x) * fB; + + if (fA > fB) + std::swap(fA, fB); + + fA = clampf(fA - g_fOCextTriangle, 0, m_iWidth - 1); + fB = clampf(fB + g_fOCextTriangle, 0, m_iWidth - 1); + + // , + for (int x = fA; x <= fB; ++x) + { + int iPosPixel = (y * m_iWidth) + x; + if (iPosPixel < m_iCountPixels) + { + float fCurrDepth = (-(vNormal.x * float(x) + vNormal.y * float(y) + fD) / vNormal.z); + + if (fCurrDepth >= 0.f && m_pArrDepthBufferReProjection[iPosPixel] >= (fCurrDepth - m_fBiasDepth)) + { + return true; + } + } + } + } + + + iSegmentHeight = vPointC.y - vPointB.y + 1; + + if (iSegmentHeight == 0) + return false; + + iStartY = clampf(vPointB.y, 0, m_iHeight - 1); + iFinishY = clampf(vPointC.y, 0, m_iHeight - 1); + + for (int y = iStartY; y <= iFinishY; ++y) + { + float fA = (y - vPointA.y) / iTotalHeight; + float fB = (y - vPointB.y) / iSegmentHeight; + fA = vPointA.x + (vPointC.x - vPointA.x) * fA; + fB = vPointB.x + (vPointC.x - vPointB.x) * fB; + + if (fA > fB) + std::swap(fA, fB); + + fA = clampf(fA - g_fOCextTriangle, 0, m_iWidth - 1); + fB = clampf(fB + g_fOCextTriangle, 0, m_iWidth - 1); + + // , + for (int x = fA; x <= fB; ++x) + { + int iPosPixel = (y * m_iWidth) + x; + if (iPosPixel < m_iCountPixels) + { + float fCurrDepth = (-(vNormal.x * float(x) + vNormal.y * float(y) + fD) / vNormal.z); + + if (fCurrDepth >= 0.f && m_pArrDepthBufferReProjection[iPosPixel] >= (fCurrDepth - m_fBiasDepth)) + { + return true; + } + } + } + } + + return isVisible; +} \ No newline at end of file diff --git a/source/gcore/oc.h b/source/gcore/oc.h new file mode 100644 index 0000000000000000000000000000000000000000..e6fcf9b15f3213d770c31079c3ab7adde74dba6a --- /dev/null +++ b/source/gcore/oc.h @@ -0,0 +1,142 @@ + +/*********************************************************** +Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#ifndef __OC_H +#define __OC_H + +#include +#include +#include + +#include + +extern IDirect3DDevice9 *g_pDXDevice; +extern D3DPRESENT_PARAMETERS g_oD3DAPP; + +//! occlusion culling +#define OC_SIZE_COEF 0.25f + +//! ( ) occlusion culling true +#define OC_DIST_NEAR_NOT_CULL 4.f + +//! occlusion culling +//static float g_fOCbiasDepth = 0.0001f; + +//! +const float g_fOCextTriangle = 2.f; + +//! occlusion culling +const float3 g_cvOCext(0.05f, 0.05f, 0.05f); + +//########################################################################## + +/*inline bool OC_RasterizeQuad(const float3 &vA, const float3 &vB, const float3 &vC, const float3 &vD, const float2 &vNearFar) +{ + float3 vNormal = TriGetNormal(vA, vB, vC); + return (OC_TriangleRasterize(vA, vB, vC, false, vNormal, vNearFar) || OC_TriangleRasterize(vB, vC, vD, false, vNormal, vNearFar)); +}*/ + +void SwapFloat3(float3 &vA, float3 &vB); +void TriGetSphere(const float3 &vA, const float3 &vB, const float3 &vC, float &fRadius, float2 &vCenter); +void QuadGetSphere(const float2 &vMin, const float2 &vMax, float &fRadius, float2 &vCenter); + +//########################################################################## + +class COcclusionCulling +{ +public: + + SX_ALIGNED_OP_MEM + + COcclusionCulling(); + ~COcclusionCulling(); + + //! + void init(int iWidth, int iHeight); + + //! + void onLostDevice(); + + //! + void onResetDevice(int iWidth, int iHeight); + + //! / + void setEnable(bool isEnable); + + //! + bool getEnable(); + + /*! + \param idDepthMap - rt + \param pFrustum - + */ + void update(ID idDepthMap, const IFrustum *pFrustum); + + //! + void reprojection(); + + //! + bool comVisible(const float3 *pMax, const float3 *pMin); + +protected: + + bool triFrustumCulling(const float3 &vA, const float3 &vB, const float3 &vC); + bool triRasterize(const float4 &vA, const float4 &vB, const float4 &vC, bool isRasterize, const float3 &vNormal2, const float2_t &vNearFar); + + //! surfaces + IDirect3DSurface9 *m_pSurfDepthBuffer[3]; + + //! + float *m_pArrDepthBuffer = 0; + + //! + float4 *m_pArrWorldPos = 0; + + //! + float *m_pArrDepthBufferReProjection = 0; + + //! (debug) + float *m_pArrDepthBufferRasterize = 0; + + //! + bool m_isEnable; + + //! + float4x4 m_mOldView; + + //! + float4x4 m_mOldProj; + + //! + int m_iCountPixels; + + //! + int m_iWidth; + + //! + int m_iHeight; + + //! + ID m_aRTdepth[2]; + + //! #m_aRTdepth + int m_iCurrRTdepth; + + + ID m_idVS_ScreenOut; + ID m_idPS_ScreenOut; + ID m_idPS_FindMax9; + + //! + const IFrustum *m_pFrustum; + + int m_iCountFC; + int m_iCountFCfail; + + float m_fBiasDepth; +}; + +#endif \ No newline at end of file diff --git a/source/gcore/sxgcore.cpp b/source/gcore/sxgcore.cpp index 67b8058a7269fc4be3f8fb848b5163faddd7647b..71cbaf59a92fe6a2a5633c8c84cbfb6742eee6bd 100644 --- a/source/gcore/sxgcore.cpp +++ b/source/gcore/sxgcore.cpp @@ -12,60 +12,40 @@ See the license in LICENSE #include #include #include +#include #include #include +#include +#include + #if !defined(DEF_STD_REPORT) #define DEF_STD_REPORT report_func g_fnReportf = DefReport; #endif -/*inline void LibReport(int iLevel, const char *szFormat, ...) -{ - static char szStr[REPORT_MSG_MAX_LEN]; - szStr[0] = 0; - int iStrLen = sizeof(szStr); - format_str(szStr, szFormat); +//########################################################################## + +#define SXGCORE_VERSION 1 - g_fnReportf(iLevel, SX_LIB_NAME, szStr); -}*/ IDirect3DDevice9 *g_pDXDevice = 0; D3DPRESENT_PARAMETERS g_oD3DAPP; IDirect3D9 *g_pD3D9 = 0; ID3DXFont *g_pFPStext = 0; -Array g_aArrModes; - -IDirect3DSurface9 *g_pOCsurfDepthBuffer[3]; -float *g_pOCarrDepthBuffer = 0; -float4 *g_pOCarrWorldPos = 0; -float *g_pOCarrDepthBufferReProjection = 0; -float *g_pOCarrDepthBufferRasterize = 0; -bool g_isOCenable = false; -float4x4 g_mOColdView; -float4x4 g_mOColdProj; -int g_iOCcountPixels = 0; -int g_iOCWidth = 0; -int g_iOCHeight = 0; -ID RT_DepthOC[2]; -int g_iOCcurrDepth = 0; -ID VS_ScreenOut = -1; -ID PS_ScreenOut = -1; -ID PS_FindMax9 = -1; - -//! occlusion culling -float g_fOCbiasDEpth = 0.0001f; - -//! -float g_fOCextTriangle = 2.f; - -//! occlusion culling -#define OC_SIZE_COEF 0.25f - -//! ( ) occlusion culling true -#define OC_DIST_NEAR_NOT_CULL 4.f +Array g_aModes; + +IDirect3DVertexDeclaration9 *g_pStaticVertexDecl = 0; + +CShaderManager *g_pManagerShaders = 0; +CreatorTextures *g_pManagerRenderTargets = 0; +LoaderTextures *g_pManagerTextures = 0; +ID3DXMesh *g_pScreenTexture = 0; +CSkyBox *g_pSkyBox = 0; +CSkyClouds *g_pSkyClouds = 0; +COcclusionCulling *g_pOC = 0; //########################################################################## @@ -101,122 +81,33 @@ bool StdMtlGroupIsSyngly(ID id) return false; } -g_func_dip FuncDIP = StdDrawIndexedPrimitive; -g_func_mtl_set FuncMtlSet = StdMtlSet; -g_func_mtl_load FuncMtlLoad = StdMtlLoad; -g_func_mtl_get_sort FuncMtlGetSort = StdMtlGetSort; -g_func_mtl_get_physic_type FuncMtlGetPhysicType = StdMtlGetPhysicType; -g_func_mtl_group_render_is_singly FuncMtlGroupRenderIsSingly = StdMtlGroupIsSyngly; +g_func_dip g_fnDIP = StdDrawIndexedPrimitive; +g_func_mtl_set g_fnMtlSet = StdMtlSet; +g_func_mtl_load g_fnMtlLoad = StdMtlLoad; +g_func_mtl_get_sort g_fnMtlGetSort = StdMtlGetSort; +g_func_mtl_get_physic_type g_fnMtlGetPhysicType = StdMtlGetPhysicType; +g_func_mtl_group_render_is_singly g_fnMtlGroupRenderIsSingly = StdMtlGroupIsSyngly; //########################################################################## -IDirect3DVertexDeclaration9 *g_pStaticVertexDecl = 0; - - -#define SXGCORE_VERSION 1 - -CShaderManager *g_pManagerShaders = 0; -CreatorTextures *g_pManagerRenderTargets = 0; -LoaderTextures *g_pManagerTextures = 0; -ID3DXMesh *g_pScreenTexture = 0; -CSkyBox *g_pSkyBox = 0; -CSkyClouds *g_pSkyClouds = 0; - - #define SG_PRECOND(retval) if(!g_pDXDevice){ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxgcore is not init", GEN_MSG_LOCATION); return retval;} #define SG_PRECOND_SKY_BOX(retval) SG_PRECOND(retval _VOID); if(!g_pSkyBox){ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sky_box is not init", GEN_MSG_LOCATION); return retval;} #define SG_PRECOND_SKY_CLOUDS(retval) SG_PRECOND(retval _VOID); if(!g_pSkyClouds){ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sky_clouds is not init", GEN_MSG_LOCATION); return retval;} +#define SG_PRECOND_SKY_OC(retval) SG_PRECOND(retval _VOID); if(!g_pOC){ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - occlusion culling is not init", GEN_MSG_LOCATION); return retval;} //########################################################################## void GCoreInit(HWND hWnd, int iWidth, int iHeight, bool isWindowed, DWORD dwFlags) { - g_pD3D9 = Direct3DCreate9(D3D_SDK_VERSION); - - if (!g_pD3D9) - { - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - none detected d3d", GEN_MSG_LOCATION); - return; - } - - D3DCAPS9 caps; - g_pD3D9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps); - - memset(&g_oD3DAPP, 0, sizeof(g_oD3DAPP)); - g_oD3DAPP.BackBufferWidth = iWidth; - g_oD3DAPP.BackBufferHeight = iHeight; - g_oD3DAPP.BackBufferFormat = D3DFMT_A8R8G8B8; - g_oD3DAPP.BackBufferCount = 1; - g_oD3DAPP.MultiSampleType = D3DMULTISAMPLE_NONE; - g_oD3DAPP.MultiSampleQuality = 0; - g_oD3DAPP.SwapEffect = D3DSWAPEFFECT_DISCARD; - g_oD3DAPP.hDeviceWindow = hWnd; - g_oD3DAPP.Windowed = isWindowed; - g_oD3DAPP.EnableAutoDepthStencil = true; - g_oD3DAPP.AutoDepthStencilFormat = D3DFMT_D24S8; - g_oD3DAPP.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL | dwFlags | D3DCREATE_MULTITHREADED; - g_oD3DAPP.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT; - g_oD3DAPP.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; - - if (FAILED(g_pD3D9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING | dwFlags | D3DCREATE_MULTITHREADED, &g_oD3DAPP, &g_pDXDevice))) - { - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - failed initialized d3d", GEN_MSG_LOCATION); - return; - } - - D3DXFONT_DESC LF; - ZeroMemory(&LF, sizeof(D3DXFONT_DESC)); - LF.Height = 14; - LF.Width = 7; - LF.Weight = 10; - LF.Italic = 0; - LF.CharSet = DEFAULT_CHARSET; - sprintf(LF.FaceName, "Courier New"); - - D3DXCreateFontIndirect(g_pDXDevice, &LF, &g_pFPStext); - - D3DVERTEXELEMENT9 oLayoutQuad[] = - { - { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, - { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 }, - D3DDECL_END() - }; + InitDevice(hWnd, iWidth, iHeight, isWindowed, dwFlags); + InitFPStext(); + InitFullScreenQuad(); - //IDirect3DVertexDeclaration9* VertexDeclarationQuad; - //GData::g_pDXDevice->CreateVertexDeclaration(layoutquad, &VertexDeclarationQuad); - - D3DXCreateMesh(2, 4, D3DXMESH_MANAGED, oLayoutQuad, g_pDXDevice, &g_pScreenTexture); - - struct VERTEX_SCREEN_TEXTURE { float x, y, z, tx, ty, tz; }; - - const float fOffsetPixelX = 1.0f / float(g_oD3DAPP.BackBufferWidth); - const float fOffsetPixelY = 1.0f / float(g_oD3DAPP.BackBufferHeight); - - VERTEX_SCREEN_TEXTURE aVertices[] = - { - { -1.0f - fOffsetPixelX, -1.0f + fOffsetPixelY, 1.0f, 0.0f, 1.0f, 0 }, - { -1.0f - fOffsetPixelX, 1.0f + fOffsetPixelY, 1.0f, 0.0f, 0.0f, 1 }, - { 1.0f - fOffsetPixelX, 1.0f + fOffsetPixelY, 1.0f, 1.0f, 0.0f, 2 }, - { 1.0f - fOffsetPixelX, -1.0f + fOffsetPixelY, 1.0f, 1.0f, 1.0f, 3 }, - }; - - void * pVertices; - if (!FAILED(g_pScreenTexture->LockVertexBuffer(0, (void**)&pVertices))) - { - memcpy(pVertices, aVertices, sizeof(aVertices)); - g_pScreenTexture->UnlockVertexBuffer(); - } - - WORD *pIndeces = 0; - g_pScreenTexture->LockIndexBuffer(0, (void**)&pIndeces); - pIndeces[0] = 0; pIndeces[1] = 1; pIndeces[2] = 2; - pIndeces[3] = 0; pIndeces[4] = 2; pIndeces[5] = 3; - g_pScreenTexture->UnlockIndexBuffer(); - - g_pManagerShaders = new CShaderManager(); g_pManagerRenderTargets = new CreatorTextures(); g_pManagerTextures = new LoaderTextures(); + g_pOC = new COcclusionCulling(); + g_pOC->init(g_oD3DAPP.BackBufferWidth, g_oD3DAPP.BackBufferHeight); D3DVERTEXELEMENT9 oLayoutStatic[] = { @@ -228,49 +119,60 @@ void GCoreInit(HWND hWnd, int iWidth, int iHeight, bool isWindowed, DWORD dwFlag g_pDXDevice->CreateVertexDeclaration(oLayoutStatic, &g_pStaticVertexDecl); + InitArrModes(); + InitRT4Gbuffer(); + LoadShaders(); +} - // - DEVMODE oDevMode; - int iNum = 0; - while (EnumDisplaySettings(NULL, iNum, &oDevMode)) - { - iNum++; - if (oDevMode.dmBitsPerPel >= 32 && oDevMode.dmPelsWidth >= 800 && oDevMode.dmPelsHeight >= 600) - { - bool isUnic = true; - for (int i = 0, il = g_aArrModes.size(); i < il; ++i) - { - if (g_aArrModes[i].dmPelsWidth == oDevMode.dmPelsWidth && g_aArrModes[i].dmPelsHeight == oDevMode.dmPelsHeight) - { - isUnic = false; - break; - } - } +//########################################################################## - if (isUnic) - g_aArrModes.push_back(oDevMode); - } - } +SX_LIB_API ID SGCore_GbufferGetRT_ID(DS_RT type) +{ + SG_PRECOND(-1); - - g_iOCWidth = float(iWidth * OC_SIZE_COEF); - g_iOCHeight = float(iHeight * OC_SIZE_COEF); - g_iOCcountPixels = g_iOCWidth * g_iOCHeight; - - g_pDXDevice->CreateOffscreenPlainSurface(g_iOCWidth, g_iOCHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &g_pOCsurfDepthBuffer[0], 0); - g_pDXDevice->CreateOffscreenPlainSurface(g_iOCWidth, g_iOCHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &g_pOCsurfDepthBuffer[1], 0); - g_pDXDevice->CreateOffscreenPlainSurface(g_iOCWidth, g_iOCHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &g_pOCsurfDepthBuffer[2], 0); - g_pOCarrDepthBuffer = new float[g_iOCcountPixels+1]; - g_pOCarrWorldPos = new float4[g_iOCcountPixels+1]; - g_pOCarrDepthBufferReProjection = new float[g_iOCcountPixels+1]; - g_pOCarrDepthBufferRasterize = new float[g_iOCcountPixels]; - - RT_DepthOC[0] = SGCore_RTAdd(g_iOCWidth, g_iOCHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "depth_oc", 0.25f); - RT_DepthOC[1] = SGCore_RTAdd(g_iOCWidth, g_iOCHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "depth_oc2", 0.25f); - - VS_ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_quad_render.vs", "pp_quad_render.vs", SHADER_CHECKDOUBLE_PATH); - PS_ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_quad_render.ps", "pp_quad_render.ps", SHADER_CHECKDOUBLE_PATH); - PS_FindMax9 = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_depth_find_max9.ps", "pp_depth_find_max9.ps", SHADER_CHECKDOUBLE_NAME); + if (type == DS_RT_COLOR) + return gcore_data::rt_id::idColorScene; + else if (type == DS_RT_NORMAL) + return gcore_data::rt_id::idNormalScene; + else if (type == DS_RT_PARAM) + return gcore_data::rt_id::idParamsScene; + else if (type == DS_RT_DEPTH) + return gcore_data::rt_id::idDepthScene; + else if (type == DS_RT_DEPTH0) + return gcore_data::rt_id::idDepthScene0; + else if (type == DS_RT_DEPTH1) + return gcore_data::rt_id::idDepthScene1; + + else if (type == DS_RT_AMBIENTDIFF) + return gcore_data::rt_id::idLightAmbientDiff; + else if (type == DS_RT_SPECULAR) + return gcore_data::rt_id::idLightSpecular; + + else if (type == DS_RT_SCENELIGHT) + return gcore_data::rt_id::idLigthCom; + else if (type == DS_RT_SCENELIGHT2) + return gcore_data::rt_id::idLigthCom2; + + else if (type == DS_RT_ADAPTEDLUM) + return gcore_data::rt_id::GetCurrAdaptedLum(); + + return -1; +} + +SX_LIB_API IDirect3DTexture9* SGCore_GbufferGetRT(DS_RT type) +{ + SG_PRECOND(0); + + ID id = SGCore_GbufferGetRT_ID(type); + if (id >= 0) + return SGCore_RTGetTexture(id); + else + return 0; +} + +SX_LIB_API void SGCore_ToneMappingCom(DWORD timeDelta, float fFactorAdapted) +{ + ToneMappingCom(timeDelta, fFactorAdapted); } //########################################################################## @@ -310,9 +212,9 @@ SX_LIB_API const DEVMODE* SGCore_GetModes(int *pCount) SG_PRECOND(0); if (pCount) - *pCount = g_aArrModes.size(); + *pCount = g_aModes.size(); - return &(g_aArrModes[0]); + return &(g_aModes[0]); } SX_LIB_API HWND SGCore_GetHWND() @@ -324,13 +226,7 @@ SX_LIB_API void SGCore_AKill() { SG_PRECOND(_VOID); - mem_release(g_pOCsurfDepthBuffer[0]); - mem_release(g_pOCsurfDepthBuffer[1]); - mem_release(g_pOCsurfDepthBuffer[2]); - mem_delete_a(g_pOCarrDepthBuffer); - mem_delete_a(g_pOCarrDepthBufferReProjection); - mem_delete_a(g_pOCarrWorldPos); - mem_delete_a(g_pOCarrDepthBufferRasterize); + mem_delete(g_pOC); mem_delete(g_pManagerShaders); mem_delete(g_pManagerRenderTargets); @@ -376,34 +272,16 @@ SX_LIB_API void SGCore_OnLostDevice() { SG_PRECOND(_VOID); - mem_release(g_pOCsurfDepthBuffer[0]); - mem_release(g_pOCsurfDepthBuffer[1]); - mem_release(g_pOCsurfDepthBuffer[2]); - mem_delete_a(g_pOCarrDepthBuffer); - mem_delete_a(g_pOCarrDepthBufferReProjection); - mem_delete_a(g_pOCarrWorldPos); - mem_delete_a(g_pOCarrDepthBufferRasterize); - g_pFPStext->OnLostDevice(); g_pManagerRenderTargets->OnLostDevice(); + + g_pOC->onLostDevice(); } SX_LIB_API bool SGCore_OnDeviceReset(int iWidth, int iHeight, bool isWindowed) { SG_PRECOND(false); - g_iOCWidth = float(iWidth * OC_SIZE_COEF); - g_iOCHeight = float(iHeight * OC_SIZE_COEF); - g_iOCcountPixels = g_iOCWidth * g_iOCHeight; - - g_pDXDevice->CreateOffscreenPlainSurface(g_iOCWidth, g_iOCHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &g_pOCsurfDepthBuffer[0], 0); - g_pDXDevice->CreateOffscreenPlainSurface(g_iOCWidth, g_iOCHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &g_pOCsurfDepthBuffer[1], 0); - g_pDXDevice->CreateOffscreenPlainSurface(g_iOCWidth, g_iOCHeight, D3DFMT_R32F, D3DPOOL_SYSTEMMEM, &g_pOCsurfDepthBuffer[2], 0); - g_pOCarrDepthBuffer = new float[g_iOCcountPixels + 1]; - g_pOCarrWorldPos = new float4[g_iOCcountPixels + 1]; - g_pOCarrDepthBufferReProjection = new float[g_iOCcountPixels + 1]; - g_pOCarrDepthBufferRasterize = new float[g_iOCcountPixels]; - g_oD3DAPP.BackBufferWidth = iWidth; g_oD3DAPP.BackBufferHeight = iHeight; g_oD3DAPP.Windowed = isWindowed; @@ -417,6 +295,7 @@ SX_LIB_API void SGCore_OnResetDevice() g_pFPStext->OnResetDevice(); g_pManagerRenderTargets->OnResetDevice(); + g_pOC->onResetDevice(g_oD3DAPP.BackBufferWidth, g_oD3DAPP.BackBufferHeight); struct VERTEX_SCREEN_TEXTURE { float x, y, z, tx, ty, tz; }; @@ -437,6 +316,8 @@ SX_LIB_API void SGCore_OnResetDevice() memcpy(pVertices, aVertices, sizeof(aVertices)); g_pScreenTexture->UnlockVertexBuffer(); } + + gcore_data::rt_id::iHowAdaptedLum = 0; } SX_LIB_API void SGCore_ScreenQuadDraw() @@ -450,919 +331,103 @@ SX_LIB_API void SGCore_ScreenQuadDraw() SX_LIB_API void SGCore_DIP(UINT uiTypePrimitive, long lBaseVertexIndex, UINT uiMinVertexIndex, UINT uiNumVertices, UINT uiStartIndex, UINT uiPrimitiveCount) { SG_PRECOND(_VOID); - FuncDIP(uiTypePrimitive, lBaseVertexIndex, uiMinVertexIndex, uiNumVertices, uiStartIndex, uiPrimitiveCount); + g_fnDIP(uiTypePrimitive, lBaseVertexIndex, uiMinVertexIndex, uiNumVertices, uiStartIndex, uiPrimitiveCount); } SX_LIB_API void SGCore_MtlSet(ID id, float4x4 *pWorld) { SG_PRECOND(_VOID); - FuncMtlSet(id, pWorld); + g_fnMtlSet(id, pWorld); } SX_LIB_API ID SGCore_MtlLoad(const char *szName, int iMtlType) { SG_PRECOND(-1); - return FuncMtlLoad(szName, iMtlType); + return g_fnMtlLoad(szName, iMtlType); } SX_LIB_API int SGCore_MtlGetSort(ID id) { SG_PRECOND(-1); - return FuncMtlGetSort(id); + return g_fnMtlGetSort(id); } SX_LIB_API int SGCore_MtlGetPhysicType(ID id) { SG_PRECOND(-1); - return FuncMtlGetPhysicType(id); + return g_fnMtlGetPhysicType(id); } SX_LIB_API bool SGCore_MtlGroupRenderIsSingly(ID id) { SG_PRECOND(false); - return FuncMtlGroupRenderIsSingly(id); + return g_fnMtlGroupRenderIsSingly(id); } SX_LIB_API void SGCore_SetFunc_DIP(g_func_dip fnFunc) { SG_PRECOND(_VOID); - FuncDIP = fnFunc; + g_fnDIP = fnFunc; } SX_LIB_API void SGCore_SetFunc_MtlSet(g_func_mtl_set fnFunc) { SG_PRECOND(_VOID); - FuncMtlSet = fnFunc; + g_fnMtlSet = fnFunc; } SX_LIB_API void SGCore_SetFunc_MtlLoad(g_func_mtl_load fnFunc) { SG_PRECOND(_VOID); - FuncMtlLoad = fnFunc; + g_fnMtlLoad = fnFunc; } SX_LIB_API void SGCore_SetFunc_MtlGetSort(g_func_mtl_get_sort fnFunc) { SG_PRECOND(_VOID); - FuncMtlGetSort = fnFunc; + g_fnMtlGetSort = fnFunc; } SX_LIB_API void SGCore_SetFunc_MtlGetPhysicType(g_func_mtl_get_physic_type fnFunc) { SG_PRECOND(_VOID); - FuncMtlGetPhysicType = fnFunc; + g_fnMtlGetPhysicType = fnFunc; } SX_LIB_API void SGCore_SetFunc_MtlGroupRenderIsSingly(g_func_mtl_group_render_is_singly fnFunc) { SG_PRECOND(_VOID); - FuncMtlGroupRenderIsSingly = fnFunc; + g_fnMtlGroupRenderIsSingly = fnFunc; } //########################################################################## -//! occlusion culling -const float3 g_cvOCext(0.05f, 0.05f, 0.05f); - SX_LIB_API void SGCore_OC_SetEnable(bool isEnable) { - SG_PRECOND(_VOID); - g_isOCenable = isEnable; + SG_PRECOND_SKY_OC(_VOID); + g_pOC->setEnable(isEnable); } -const IFrustum *g_pFrustum = 0; -int g_iOCcountFC = 0; -int g_iOCcountFCfail = 0; - SX_LIB_API void SGCore_OC_Update(ID idDepthMap, const IFrustum *pFrustum) { - SG_PRECOND(_VOID); - - if (!g_isOCenable) - return; - - g_pFrustum = pFrustum; - g_iOCcountFC = 0; - g_iOCcountFCfail = 0; - - - static const float *r_near = GET_PCVAR_FLOAT("r_near"); - static const float *r_far = GET_PCVAR_FLOAT("r_far"); - - // - - if (!r_near || !r_far) - { - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - cvar r_near or r_far is not found!", GEN_MSG_LOCATION); - return; - } - - static const float *r_default_fov = GET_PCVAR_FLOAT("r_default_fov"); - - // fov - - if (!r_default_fov) - { - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - cvar r_default_fov is not found!", GEN_MSG_LOCATION); - return; - } + SG_PRECOND_SKY_OC(_VOID); - g_fOCbiasDEpth = 1.f / (*r_far); - - /*float fWidth = g_oD3DAPP.BackBufferWidth * OC_SIZE_COEF; - float fHeight = g_oD3DAPP.BackBufferHeight * OC_SIZE_COEF;*/ - - IDirect3DTexture9 *pTexDepth = SGCore_RTGetTexture(idDepthMap); - IDirect3DTexture9 *pTexDepthOC = SGCore_RTGetTexture(RT_DepthOC[g_iOCcurrDepth]); - - // - g_pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - g_pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - g_pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - g_pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - LPDIRECT3DSURFACE9 RenderSurf2, BackBuf2; - - pTexDepthOC->GetSurfaceLevel(0, &RenderSurf2); - g_pDXDevice->GetRenderTarget(0, &BackBuf2); - g_pDXDevice->SetRenderTarget(0, RenderSurf2); - - SGCore_SetSamplerFilter(0, D3DTEXF_NONE); - SGCore_SetSamplerAddress(0, D3DTADDRESS_CLAMP); - - g_pDXDevice->SetTexture(0, pTexDepth); - - SGCore_ShaderBind(SHADER_TYPE_VERTEX, VS_ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, PS_FindMax9); - - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, PS_FindMax9, "g_vPixelSize", (&float2(1.f / float(g_oD3DAPP.BackBufferWidth), 1.f / float(g_oD3DAPP.BackBufferHeight)))); - - SGCore_ScreenQuadDraw(); - - SGCore_ShaderUnBind(); - - g_pDXDevice->SetRenderTarget(0, BackBuf2); - - mem_release(RenderSurf2); - mem_release(BackBuf2); - - //********************************************************************** - - // - LPDIRECT3DSURFACE9 pDepthSurf; - - int iCurrOld = 1 - g_iOCcurrDepth; - - pTexDepthOC = SGCore_RTGetTexture(RT_DepthOC[g_iOCcurrDepth]); - - pTexDepthOC->GetSurfaceLevel(0, &pDepthSurf); - g_pDXDevice->GetRenderTargetData(pDepthSurf, g_pOCsurfDepthBuffer[g_iOCcurrDepth]); - - D3DLOCKED_RECT srect; - g_pOCsurfDepthBuffer[iCurrOld]->LockRect(&srect, 0, D3DLOCK_READONLY | D3DLOCK_DONOTWAIT); - - memcpy(g_pOCarrDepthBuffer, srect.pBits, sizeof(float)* g_iOCcountPixels); - g_pOCsurfDepthBuffer[iCurrOld]->UnlockRect(); - - mem_release(pDepthSurf); - - //********************************************************************** - - float fPosX = 0, fPosY = 0; - - float4 vWorldPos; - - float4x4 mView, mProjection; - Core_RMatrixGet(G_RI_MATRIX_OBSERVER_VIEW, &mView); - Core_RMatrixGet(G_RI_MATRIX_OBSERVER_PROJ, &mProjection); - - float4x4 mViewProj = g_mOColdView * g_mOColdProj;// = mView * mProjection; - float fD = 0.f; - float4x4 mInvVP = SMMatrixInverse(&fD, mViewProj); - - // - /*for (int i = 0; i < iCountPixels; ++i) - { - fPosY = int(float(i) / fWidth); - fPosX = int(i - (fPosY * fWidth)); - - fPosX = fPosX / fWidth; - fPosY = fPosY / fHeight; - - fPosX = 2.f * fPosX - 1.f; - fPosY = 2.f * (1.f - fPosY) - 1.f; - - vWorldPos = SMVector4Transform(float4(fPosX, fPosY, g_pOCarrDepthBuffer[i], 1.f), mInvVP); - vWorldPos /= vWorldPos.w; - g_pOCarrWorldPos[i] = vWorldPos; - - //g_pOCarrDepthBuffer[i] = (*r_near) / ((*r_far) + (*r_near) - g_pOCarrDepthBuffer[i] * ((*r_far) - (*r_near))); //vWorldPos.z / (*r_far); - }*/ - - float3 vObserverPos; - Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vObserverPos); - - float fTanHalfFOV = tan((*r_default_fov) * 0.5f); - float fAspectRatio = float(g_iOCWidth) / float(g_iOCHeight); - float fFarY = fTanHalfFOV * (*r_far); - float fFarX = fFarY * fAspectRatio; - - float4 vEyeRay, vWorldRay; - float4x4 mInvView = SMMatrixInverse(&fD, g_mOColdView); - - /*for (int i = 0; i < g_iOCcountPixels; ++i) - { - //float linearDepth = (2.0 * (*r_near)) / ((*r_far) + (*r_near) - g_pArrDepthBufferOC[i] * ((*r_far) - (*r_near))); - //g_pArrDepthBufferOC[i] = linearDepth; - - fPosY = int(float(i) / g_iOCWidth); - fPosX = int(i - (fPosY * g_iOCWidth)); - - fPosX = fPosX / g_iOCWidth; - fPosY = fPosY / g_iOCHeight; - - fPosX = 2.f * fPosX - 1.f; - fPosY = 2.f * (1.f - fPosY) - 1.f; - vEyeRay = float4((fPosX)* fFarX, (fPosY)* fFarY, (*r_far), 0.f); - vWorldRay = SMVector4Transform(vEyeRay, mInvView); - - vWorldPos = float4(vObserverPos + vWorldRay * g_pOCarrDepthBuffer[i], 1.f); - g_pOCarrWorldPos[i] = vWorldPos; - int qwerty = 0; - }*/ - - float4 aWorldRays[4]; - aWorldRays[0] = SMVector4Transform(float4(-1.f * fFarX, -1.f * fFarY, (*r_far), 0.f), mInvView); - aWorldRays[1] = SMVector4Transform(float4(1.f * fFarX, -1.f * fFarY, (*r_far), 0.f), mInvView); - aWorldRays[2] = SMVector4Transform(float4(1.f * fFarX, 1.f * fFarY, (*r_far), 0.f), mInvView); - aWorldRays[3] = SMVector4Transform(float4(-1.f * fFarX, 1.f * fFarY, (*r_far), 0.f), mInvView); - - float4 vWorldRay0, vWorldRay1; - - for (int x = 0; x < g_iOCWidth; ++x) - { - vWorldRay0 = SMVectorLerp(aWorldRays[0], aWorldRays[1], float(x) / g_iOCWidth); - vWorldRay1 = SMVectorLerp(aWorldRays[3], aWorldRays[2], float(x) / g_iOCWidth); - for (int y = 0; y < g_iOCHeight; ++y) - { - int iPosPixel = (y * g_iOCWidth) + x; - vWorldRay = SMVectorLerp(vWorldRay1, vWorldRay0, float(y) / g_iOCHeight); - vWorldPos = vObserverPos + vWorldRay * g_pOCarrDepthBuffer[iPosPixel]; - vWorldPos.w = 1.f; - g_pOCarrWorldPos[iPosPixel] = vWorldPos; - } - } - - g_mOColdView = mView; - g_mOColdProj = mProjection; - - ++g_iOCcurrDepth; - - if (g_iOCcurrDepth >= 2) - g_iOCcurrDepth = 0; - - - if (GetKeyState('M')) - { - g_pOCsurfDepthBuffer[2]->LockRect(&srect, 0, D3DLOCK_READONLY); - - memcpy(srect.pBits, g_pOCarrDepthBuffer, sizeof(float) * g_iOCcountPixels); - g_pOCsurfDepthBuffer[2]->UnlockRect(); - - D3DXSaveSurfaceToFile("C:/1/g_pOCsurfDepthBuffer.jpg", D3DXIFF_JPG, g_pOCsurfDepthBuffer[2], NULL, NULL); - } + g_pOC->update(idDepthMap, pFrustum); } - -/*struct CTriV -{ - float3_t m_vA; - float3_t m_vB; - float3_t m_vC; -}; - -Array g_aVetrs;*/ - SX_LIB_API void SGCore_OC_Reprojection() { - SG_PRECOND(_VOID); - - if (!g_isOCenable) - return; - - /*if (GetAsyncKeyState('C')) - g_aVetrs.clear();*/ - - static const float *r_near = GET_PCVAR_FLOAT("r_near"); - static const float *r_far = GET_PCVAR_FLOAT("r_far"); - - if (!r_near || !r_far) - { - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - cvar r_near or r_far is not found!", GEN_MSG_LOCATION); - return; - } - - /*float fWidth = g_oD3DAPP.BackBufferWidth * OC_SIZE_COEF; - float fHeight = g_oD3DAPP.BackBufferHeight * OC_SIZE_COEF;*/ - - float4x4 mView, mProjection; - Core_RMatrixGet(G_RI_MATRIX_OBSERVER_VIEW, &mView); - Core_RMatrixGet(G_RI_MATRIX_OBSERVER_PROJ, &mProjection); - - float4x4 mViewProj = mView * mProjection; - - //int iCountPixels = fWidth * fHeight; - - float4 vNewPos; - - for (int i = 0; i < g_iOCcountPixels; ++i) - { - g_pOCarrDepthBufferReProjection[i] = 1.f; - g_pOCarrDepthBufferRasterize[i] = 1.f; - } - - float3 vObserverPos; - Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vObserverPos); - - float2 vNewPos2; - - // , screen-space - for (int i = 0; i < g_iOCcountPixels; ++i) - { - vNewPos = SMVector4Transform(g_pOCarrWorldPos[i], mViewProj); - - vNewPos.x /= abs(vNewPos.w); - vNewPos.y /= abs(vNewPos.w); - vNewPos.z = (vNewPos.z + (*r_near)) / (*r_far); - /*vNewPos.x /= abs(vNewPos.w); - vNewPos.y /= abs(vNewPos.w); - vNewPos.z /= abs(vNewPos.w);*/ - - vNewPos.x = vNewPos.x * 0.5f + 0.5f; - vNewPos.y = (vNewPos.y * (-0.5f) + 0.5f); - - // , - - vNewPos2.x = float(int(vNewPos.x * 10000.f) / 10000.f); - vNewPos2.y = float(int(vNewPos.y * 10000.f) / 10000.f); - - if (vNewPos2.x == 0.f || vNewPos2.x == 1.f) - vNewPos.x = vNewPos2.x; - - if (vNewPos2.y == 0.f || vNewPos2.y == 1.f) - vNewPos.y = vNewPos2.y; - - //****************************************************************** - - if ((vNewPos.x <= 1.f && vNewPos.x >= 0.f) && (vNewPos.y <= 1.f && vNewPos.y >= 0.f)) - { - int x = floor(vNewPos.x * float(g_iOCWidth) + 0.5f); - int y = floor(vNewPos.y * g_iOCHeight + 0.5f); - int iPosPixel = int(y * g_iOCWidth) + x; - - if (iPosPixel > g_iOCcountPixels) - int qwerty = 0; - else - { - // , - if (g_pOCarrDepthBufferReProjection[iPosPixel] >= 1.f || vNewPos.z > g_pOCarrDepthBufferReProjection[iPosPixel]) - g_pOCarrDepthBufferReProjection[iPosPixel] = vNewPos.z; - } - } - } - - - if (GetKeyState('N')) - { - D3DLOCKED_RECT srect; - g_pOCsurfDepthBuffer[2]->LockRect(&srect, 0, D3DLOCK_READONLY); - - memcpy(srect.pBits, g_pOCarrDepthBufferReProjection, sizeof(float) * g_iOCcountPixels); - g_pOCsurfDepthBuffer[2]->UnlockRect(); - D3DXSaveSurfaceToFile("C:/1/g_pSurfDepthBufferOCreproj.jpg", D3DXIFF_JPG, g_pOCsurfDepthBuffer[2], NULL, NULL); - } -} - -inline void SwapFloat3(float3 &vA, float3 &vB) -{ - float3 vV; - vV = vA; - vA = vB; - vB = vV; -} - -inline void TriGetSphere(const float3 &vA, const float3 &vB, const float3 &vC, float &fRadius, float2 &vCenter) -{ - float x12 = vA.x - vB.x; - float x23 = vB.x - vC.x; - float x31 = vC.x - vA.x; - - float y12 = vA.y - vB.y; - float y23 = vB.y - vC.y; - float y31 = vC.y - vA.y; - - float z1 = (vA.x * vA.x) + (vA.y * vA.y); - float z2 = (vB.x * vB.x) + (vB.y * vB.y); - float z3 = (vC.x * vC.x) + (vC.y * vC.y); - - float zx = y12 * z3 + y23 * z1 + y31 * z2; - float zy = x12 * z3 + x23 * z1 + x31 * z2; - float z = x12 * y31 - y12 * x31; - - vCenter.x = -(zx / (2 * z)); - vCenter.y = zy / (2 * z); - - fRadius = sqrt(pow(vA.x - vCenter.x, 2) + (vA.y - vCenter.y, 2)); -} - -inline void QuadGetSphere(const float2 &vMin, const float2 &vMax, float &fRadius, float2 &vCenter) -{ - vCenter = (vMin + vMax) / 2; - - fRadius = SMVector2Length(vCenter - vMin); -} - - -inline bool OC_TriangleRasterize(const float4 &vA, const float4 &vB, const float4 &vC, bool isRasterize, const float3 &vNormal2, const float2_t &vNearFar) -{ - if (vA.z < 0.f && vB.z < 0.f && vC.z < 0.f) - return false; - - float3 vNormal = SMVector3Normalize(SMVector3Cross(vC - vA, vB - vA)); - - float3 vPointA = vA; - float3 vPointB = vB; - float3 vPointC = vC; - - /*int iWidth = g_oD3DAPP.BackBufferWidth * OC_SIZE_COEF; - int iHeight = g_oD3DAPP.BackBufferHeight * OC_SIZE_COEF;*/ - - //int iCountPixels = iWidth * iHeight; - - // D - float fD = -(vNormal.x * vPointA.x + vNormal.y * vPointA.y + vNormal.z * vPointA.z); - - /* - : -(N.x * x + N.y * y + D) / N.z - N - - x y - - */ - - // Y - if (vPointB.y < vPointA.y) - SwapFloat3(vPointA, vPointB); - - if (vPointC.y < vPointA.y) - SwapFloat3(vPointA, vPointC); - - if (vPointB.y > vPointC.y) - SwapFloat3(vPointB, vPointC); - - - bool isVisible = false; - - // , , - vPointA.y -= g_fOCextTriangle; - vPointC.y += g_fOCextTriangle; - - int iTotalHeight = vPointC.y - vPointA.y; - - if (iTotalHeight == 0) - return false; - - int iSegmentHeight = vPointB.y - vPointA.y + 1; - - if (iSegmentHeight == 0) - return false; - - int iStartY = clampf(vPointA.y, 0, g_iOCHeight - 1); - int iFinishY = clampf(vPointB.y, 0, g_iOCHeight - 1); - - for (int y = iStartY; y <= iFinishY; ++y) - { - /*if (!(y >= 0 && y <= iHeight - 1)) - continue;*/ - - float fA = (y - vPointA.y) / iTotalHeight; - float fB = (y - vPointA.y) / iSegmentHeight; - fA = vPointA.x + (vPointC.x - vPointA.x) * fA; - fB = vPointA.x + (vPointB.x - vPointA.x) * fB; - - if (fA > fB) - std::swap(fA, fB); - - fA = clampf(fA - g_fOCextTriangle, 0, g_iOCWidth - 1); - fB = clampf(fB + g_fOCextTriangle, 0, g_iOCWidth - 1); - - // , - for (int x = fA; x <= fB; ++x) - { - /*if (x < 0 || x > iWidth - 1) - continue;*/ - - int iPosPixel = (y * g_iOCWidth) + x; - if (iPosPixel < g_iOCcountPixels) - { - float fCurrDepth = (-(vNormal.x * float(x) + vNormal.y * float(y) + fD) / vNormal.z); - - /*if (isRasterize) - g_pOCarrDepthBufferRasterize[iPosPixel] = 0;*/ - - if (fCurrDepth >= 0.f && g_pOCarrDepthBufferReProjection[iPosPixel] >= (fCurrDepth - g_fOCbiasDEpth)) - { - //if (!isRasterize) - return true; - /*else - isVisible = true;*/ - } - } - } - } - - - iSegmentHeight = vPointC.y - vPointB.y + 1; - - if (iSegmentHeight == 0) - return false; - - iStartY = clampf(vPointB.y, 0, g_iOCHeight - 1); - iFinishY = clampf(vPointC.y, 0, g_iOCHeight - 1); - - for (int y = iStartY; y <= iFinishY; ++y) - { - /*if (!(y >= 0 && y <= iHeight - 1)) - continue;*/ - - float fA = (y - vPointA.y) / iTotalHeight; - float fB = (y - vPointB.y) / iSegmentHeight; - fA = vPointA.x + (vPointC.x - vPointA.x) * fA; - fB = vPointB.x + (vPointC.x - vPointB.x) * fB; - - if (fA > fB) - std::swap(fA, fB); - - fA = clampf(fA - g_fOCextTriangle, 0, g_iOCWidth - 1); - fB = clampf(fB + g_fOCextTriangle, 0, g_iOCWidth - 1); - - // , - for (int x = fA; x <= fB; ++x) - { - /*if (x < 0 || x > iWidth - 1) - continue;*/ - - int iPosPixel = (y * g_iOCWidth) + x; - if (iPosPixel < g_iOCcountPixels) - { - float fCurrDepth = (-(vNormal.x * float(x) + vNormal.y * float(y) + fD) / vNormal.z); - - /*if (isRasterize) - g_pOCarrDepthBufferRasterize[iPosPixel] = 0;*/ - - if (fCurrDepth >= 0.f && g_pOCarrDepthBufferReProjection[iPosPixel] >= (fCurrDepth - g_fOCbiasDEpth)) - { - //if (!isRasterize) - return true; - /*else - isVisible = true;*/ - } - } - } - } - - return isVisible; -} - -inline bool OC_RasterizeQuad(const float3 &vA, const float3 &vB, const float3 &vC, const float3 &vD, const float2 &vNearFar) -{ - float3 vNormal = TriGetNormal(vA, vB, vC); - return (OC_TriangleRasterize(vA, vB, vC, false, vNormal, vNearFar) || OC_TriangleRasterize(vB, vC, vD, false, vNormal, vNearFar)); -} + SG_PRECOND_SKY_OC(_VOID); - - -inline bool OC_FrustumCulling(const float3 &vA, const float3 &vB, const float3 &vC) -{ - if (GetAsyncKeyState('P')) - return true; - ++g_iOCcountFC; - bool isVisible = (!g_pFrustum || g_pFrustum->polyInFrustum(&vA, &vB, &vC)); - if (!isVisible) - ++g_iOCcountFCfail; - return isVisible; + g_pOC->reprojection(); } - SX_LIB_API bool SGCore_OC_IsVisible(const float3 *pMax, const float3 *pMin) { - SG_PRECOND(false); - - if (!pMax || !pMin) - { - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - min or max is null!", GEN_MSG_LOCATION); - return false; - } - - if (!g_isOCenable) - return true; - - float3 vObserverPos; - Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vObserverPos); - - static const float *r_near = GET_PCVAR_FLOAT("r_near"); - static const float *r_far = GET_PCVAR_FLOAT("r_far"); - - if (!r_near || !r_far) - { - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - cvar r_near or r_far is not found!", GEN_MSG_LOCATION); - return false; - } - - float3 vMax, vMin; - vMax = *pMax; - vMin = *pMin; - - // xz - float3 vCenter = (vMin + vMax) * 0.5f; - float fRadius = SMVector3Length2(float3(vCenter.x, 0.f, vCenter.z) - float3(vMax.x, 0, vMax.z)); - - float fDist = SMVector3Length2(vObserverPos - vCenter); - - // xz - if (fDist <= fRadius) - return true; - - fDist -= fRadius; - - // , - if (fDist >= 0.f && fDist <= OC_DIST_NEAR_NOT_CULL*OC_DIST_NEAR_NOT_CULL) - return true; - - // , , - vMax += g_cvOCext; - vMin -= g_cvOCext; - - - /*float fWidth = g_oD3DAPP.BackBufferWidth * OC_SIZE_COEF; - float fHeight = g_oD3DAPP.BackBufferHeight * OC_SIZE_COEF; - - int iCountPixels = fWidth * fHeight;*/ - - float4x4 mWorld, mView, mProjection; - Core_RMatrixGet(G_RI_MATRIX_WORLD, &mWorld); - Core_RMatrixGet(G_RI_MATRIX_OBSERVER_VIEW, &mView); - Core_RMatrixGet(G_RI_MATRIX_OBSERVER_PROJ, &mProjection); - - float4x4 mWVP = mWorld * mView *mProjection; - - - float4 aSSPoints[8]; - float4 aWPoints[8]; - aWPoints[0] = float4(vMax.x, vMax.y, vMax.z, 1.0f); - aWPoints[1] = float4(vMax.x, vMax.y, vMin.z, 1.0f); - aWPoints[2] = float4(vMax.x, vMin.y, vMax.z, 1.0f); - aWPoints[3] = float4(vMin.x, vMax.y, vMax.z, 1.0f); - aWPoints[4] = float4(vMax.x, vMin.y, vMin.z, 1.0f); - aWPoints[5] = float4(vMin.x, vMin.y, vMax.z, 1.0f); - aWPoints[6] = float4(vMin.x, vMax.y, vMin.z, 1.0f); - aWPoints[7] = float4(vMin.x, vMin.y, vMin.z, 1.0f); - - for (int i = 0; i < 8; ++i) - { - aSSPoints[i] = SMVector4Transform(aWPoints[i], mWVP); - - aSSPoints[i].x /= abs(aSSPoints[i].w); - aSSPoints[i].y /= abs(aSSPoints[i].w); - aSSPoints[i].z = ((aSSPoints[i].z + (*r_near)) / (*r_far));// *sign(aSSPoints[i].w); - - // - //float fLinearDepth = (*r_near) / ((*r_far) + (*r_near) - aPoints[i].w * ((*r_far) - (*r_near))); - - aSSPoints[i].x = aSSPoints[i].x * 0.5 + 0.5; - aSSPoints[i].y = aSSPoints[i].y * (-0.5) + 0.5; - - aSSPoints[i].x *= g_iOCWidth; - aSSPoints[i].y *= g_iOCHeight; - - aSSPoints[i].x = int(aSSPoints[i].x); - aSSPoints[i].y = int(aSSPoints[i].y); - - /*float2 vNewPos2; - vNewPos2.x = float(int(aPoints[i].x * 1000) / 1000.f); - vNewPos2.y = float(int(aPoints[i].y * 1000) / 1000.f); - - if (vNewPos2.x == 0.f || vNewPos2.x == 1.f) - aPoints[i].x = vNewPos2.x; - - if (vNewPos2.y == 0.f || vNewPos2.y == 1.f) - aPoints[i].y = vNewPos2.y; - - aPoints[i].x = int(floor(aPoints[i].x * fMapWidth + 0.5f)); - aPoints[i].y = int(floor(aPoints[i].y * fMapHeight + 0.5f));*/ - } - - float2 vNearFar((*r_near), (*r_far)); - - /*float3 aCenters[6]; - - // - aCenters[0] = (aWPoints[7] + aWPoints[1]) * 0.5f;// SMVectorLerp(aWPoints[7], aWPoints[1], 0.5f); - // - aCenters[1] = (aWPoints[0] + aWPoints[5]) * 0.5f;// SMVectorLerp(aWPoints[0], aWPoints[5], 0.5f); - - // - aCenters[2] = (aWPoints[0] + aWPoints[6]) * 0.5f;// SMVectorLerp(aWPoints[0], aWPoints[6], 0.5f); - // - aCenters[3] = (aWPoints[7] + aWPoints[2]) * 0.5f;// SMVectorLerp(aWPoints[7], aWPoints[2], 0.5f); + SG_PRECOND_SKY_OC(false); - // - aCenters[4] = (aWPoints[7] + aWPoints[3]) * 0.5f;// SMVectorLerp(aWPoints[7], aWPoints[3], 0.5f); - // - aCenters[5] = (aWPoints[0] + aWPoints[4]) * 0.5f;// SMVectorLerp(aWPoints[0], aWPoints[4], 0.5f); - - - float aDist2[6]; - - for (int i = 0; i < 6; ++i) - { - aDist2[i] = SMVector3Length2(aCenters[i] - vObserverPos); - }*/ - - - - //bool isVisible = ( - //(/*(aDist2[0] <= aDist2[1] || GetAsyncKeyState('F')*) &&*/ OC_RasterizeQuad(aSSPoints[6], aSSPoints[1], aSSPoints[4], aSSPoints[7], vNearFar)) || - - //(/*(aDist2[1] <= aDist2[0] || GetAsyncKeyState('F')) &&*/ OC_RasterizeQuad(aSSPoints[0], aSSPoints[3], aSSPoints[5], aSSPoints[2], vNearFar)) || - - //(/*(aDist2[2] <= aDist2[3] || GetAsyncKeyState('F')) &&*/ OC_RasterizeQuad(aSSPoints[3], aSSPoints[0], aSSPoints[1], aSSPoints[6], vNearFar)) || - - //(/*(aDist2[3] <= aDist2[2] || GetAsyncKeyState('F')) &&*/ OC_RasterizeQuad(aSSPoints[7], aSSPoints[4], aSSPoints[2], aSSPoints[5], vNearFar)) || - - //(/*(aDist2[4] <= aDist2[5] || GetAsyncKeyState('F')) &&*/ OC_RasterizeQuad(aSSPoints[3], aSSPoints[6], aSSPoints[7], aSSPoints[5], vNearFar)) || - - //(/*(aDist2[5] <= aDist2[4] || GetAsyncKeyState('F')) &&*/ OC_RasterizeQuad(aSSPoints[1], aSSPoints[0], aSSPoints[2], aSSPoints[4], vNearFar)) - //); - - /*bool isVisible = ( - ((aDist2[0] <= aDist2[1] || GetAsyncKeyState('F')) && - OC_TriangleRasterize(aSSPoints[6], aSSPoints[1], aSSPoints[4], false, aSSPoints[7], vNearFar) && - OC_TriangleRasterize(aSSPoints[6], aSSPoints[4], aSSPoints[7], false, aSSPoints[7], vNearFar)) || - - ((aDist2[1] <= aDist2[0] || GetAsyncKeyState('F')) && - OC_TriangleRasterize(aSSPoints[0], aSSPoints[3], aSSPoints[5], false, aSSPoints[2], vNearFar) && - OC_TriangleRasterize(aSSPoints[0], aSSPoints[5], aSSPoints[2], false, aSSPoints[2], vNearFar)) || - - ((aDist2[2] <= aDist2[3] || GetAsyncKeyState('F')) && - OC_TriangleRasterize(aSSPoints[3], aSSPoints[0], aSSPoints[1], false, aSSPoints[6], vNearFar) && - OC_TriangleRasterize(aSSPoints[3], aSSPoints[1], aSSPoints[6], false, aSSPoints[6], vNearFar)) || - - ((aDist2[3] <= aDist2[2] || GetAsyncKeyState('F')) && - OC_TriangleRasterize(aSSPoints[7], aSSPoints[4], aSSPoints[2], false, aSSPoints[5], vNearFar) && - OC_TriangleRasterize(aSSPoints[7], aSSPoints[2], aSSPoints[5], false, aSSPoints[5], vNearFar)) || - - ((aDist2[4] <= aDist2[5] || GetAsyncKeyState('F')) && - OC_TriangleRasterize(aSSPoints[3], aSSPoints[6], aSSPoints[7], false, aSSPoints[5], vNearFar) && - OC_TriangleRasterize(aSSPoints[3], aSSPoints[7], aSSPoints[5], false, aSSPoints[5], vNearFar)) || - - ((aDist2[5] <= aDist2[4] || GetAsyncKeyState('F')) && - OC_TriangleRasterize(aSSPoints[1], aSSPoints[0], aSSPoints[2], false, aSSPoints[4], vNearFar) && - OC_TriangleRasterize(aSSPoints[1], aSSPoints[2], aSSPoints[4], false, aSSPoints[4], vNearFar)) - );*/ - - - // - /*TriangleRasterize((float3)aPoints[7], (float3)aPoints[6], (float3)aPoints[1], aNormals[0], vNearFar); - TriangleRasterize((float3)aPoints[7], (float3)aPoints[1], (float3)aPoints[4], aNormals[0], vNearFar); - - // - TriangleRasterize((float3)aPoints[0], (float3)aPoints[5], (float3)aPoints[2], aNormals[0], vNearFar); - TriangleRasterize((float3)aPoints[0], (float3)aPoints[3], (float3)aPoints[5], aNormals[0], vNearFar); - - //---- - - // - TriangleRasterize((float3)aPoints[0], (float3)aPoints[1], (float3)aPoints[3], aNormals[0], vNearFar); - TriangleRasterize((float3)aPoints[1], (float3)aPoints[6], (float3)aPoints[3], aNormals[0], vNearFar); - - // - TriangleRasterize((float3)aPoints[5], (float3)aPoints[4], (float3)aPoints[2], aNormals[0], vNearFar); - TriangleRasterize((float3)aPoints[4], (float3)aPoints[5], (float3)aPoints[7], aNormals[0], vNearFar); - - //---- - - // - TriangleRasterize((float3)aPoints[0], (float3)aPoints[2], (float3)aPoints[1], aNormals[0], vNearFar); - TriangleRasterize((float3)aPoints[1], (float3)aPoints[2], (float3)aPoints[4], aNormals[0], vNearFar); - - // - TriangleRasterize((float3)aPoints[6], (float3)aPoints[5], (float3)aPoints[3], aNormals[0], vNearFar); - TriangleRasterize((float3)aPoints[5], (float3)aPoints[6], (float3)aPoints[7], aNormals[0], vNearFar);*/ - - //float3 aNormals[12]; - /*aNormals[0] = TriGetNormal(aWPoints[7], aWPoints[6], aWPoints[1]); - aNormals[1] = TriGetNormal(aWPoints[7], aWPoints[1], aWPoints[4]); - aNormals[2] = TriGetNormal(aWPoints[0], aWPoints[5], aWPoints[2]); - aNormals[3] = TriGetNormal(aWPoints[0], aWPoints[3], aWPoints[5]); - aNormals[4] = TriGetNormal(aWPoints[0], aWPoints[1], aWPoints[3]); - aNormals[5] = TriGetNormal(aWPoints[1], aWPoints[6], aWPoints[3]); - aNormals[6] = TriGetNormal(aWPoints[5], aWPoints[4], aWPoints[2]); - aNormals[7] = TriGetNormal(aWPoints[4], aWPoints[5], aWPoints[7]); - aNormals[8] = TriGetNormal(aWPoints[0], aWPoints[2], aWPoints[1]); - aNormals[9] = TriGetNormal(aWPoints[1], aWPoints[2], aWPoints[4]); - aNormals[10] = TriGetNormal(aWPoints[6], aWPoints[5], aWPoints[3]); - aNormals[11] = TriGetNormal(aWPoints[5], aWPoints[6], aWPoints[7]); - - float3 vObserverDir; - Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_DIRECTION, &vObserverDir);*/ - - //-13.92, 0.25, -52.76 - /*if (GetAsyncKeyState('C') - ) - { - if (aNormals[0].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[7]), float3_t(aWPoints[6]), float3_t(aWPoints[1]) }); - - if (aNormals[1].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[7]), float3_t(aWPoints[1]), float3_t(aWPoints[4]) }); - - if (aNormals[2].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[0]), float3_t(aWPoints[5]), float3_t(aWPoints[2]) }); - - if (aNormals[3].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[0]), float3_t(aWPoints[3]), float3_t(aWPoints[5]) }); - - if (aNormals[4].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[0]), float3_t(aWPoints[1]), float3_t(aWPoints[3]) }); - - if (aNormals[5].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[1]), float3_t(aWPoints[6]), float3_t(aWPoints[3]) }); - - if (aNormals[6].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[5]), float3_t(aWPoints[4]), float3_t(aWPoints[2]) }); - - if (aNormals[7].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[4]), float3_t(aWPoints[5]), float3_t(aWPoints[7]) }); - - if (aNormals[8].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[0]), float3_t(aWPoints[2]), float3_t(aWPoints[1]) }); - - if (aNormals[9].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[1]), float3_t(aWPoints[2]), float3_t(aWPoints[4]) }); - - if (aNormals[10].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[6]), float3_t(aWPoints[5]), float3_t(aWPoints[3]) }); - - if (aNormals[11].z > 0.f) - g_aVetrs.push_back({ float3_t(aWPoints[5]), float3_t(aWPoints[6]), float3_t(aWPoints[7]) }); - }*/ - - /*if (g_aVetrs.size() > 0) - { - SGCore_ShaderUnBind(); - - g_pDXDevice->SetTransform(D3DTS_WORLD, &((D3DXMATRIX)SMMatrixIdentity())); - g_pDXDevice->SetTransform(D3DTS_VIEW, &((D3DXMATRIX)mView)); - g_pDXDevice->SetTransform(D3DTS_PROJECTION, &((D3DXMATRIX)mProjection)); - g_pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - g_pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); - g_pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - //g_pDXDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME); - g_pDXDevice->SetTexture(0, 0); - g_pDXDevice->SetFVF(D3DFVF_XYZ); - g_pDXDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, g_aVetrs.size(), &(g_aVetrs[0]), sizeof(float3_t)); - //g_pDXDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID); - }*/ - - - /*bool isVisible = ( - ((SMVector3Dot(aNormals[0], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[7], aSSPoints[6], aSSPoints[1], false, vNearFar)) || - ((SMVector3Dot(aNormals[1], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[7], aSSPoints[1], aSSPoints[4], false, vNearFar)) || - ((SMVector3Dot(aNormals[2], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[0], aSSPoints[5], aSSPoints[2], false, vNearFar)) || - ((SMVector3Dot(aNormals[3], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[0], aSSPoints[3], aSSPoints[5], false, vNearFar)) || - ((SMVector3Dot(aNormals[4], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[0], aSSPoints[1], aSSPoints[3], false, vNearFar)) || - ((SMVector3Dot(aNormals[5], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[1], aSSPoints[6], aSSPoints[3], false, vNearFar)) || - ((SMVector3Dot(aNormals[6], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[5], aSSPoints[4], aSSPoints[2], false, vNearFar)) || - ((SMVector3Dot(aNormals[7], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[4], aSSPoints[5], aSSPoints[7], false, vNearFar)) || - ((SMVector3Dot(aNormals[8], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[0], aSSPoints[2], aSSPoints[1], false, vNearFar)) || - ((SMVector3Dot(aNormals[9], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[1], aSSPoints[2], aSSPoints[4], false, vNearFar)) || - ((SMVector3Dot(aNormals[10], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[6], aSSPoints[5], aSSPoints[3], false, vNearFar)) || - ((SMVector3Dot(aNormals[11], vObserverDir) <= 0.f || GetAsyncKeyState('F')) && OC_TriangleRasterize(aSSPoints[5], aSSPoints[6], aSSPoints[7], false, vNearFar)) - );*/ - - bool isVisible = ( - (OC_FrustumCulling(aWPoints[7], aWPoints[6], aWPoints[1]) && OC_TriangleRasterize(aSSPoints[7], aSSPoints[6], aSSPoints[1], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[7], aWPoints[1], aWPoints[4]) && OC_TriangleRasterize(aSSPoints[7], aSSPoints[1], aSSPoints[4], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[0], aWPoints[5], aWPoints[2]) && OC_TriangleRasterize(aSSPoints[0], aSSPoints[5], aSSPoints[2], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[0], aWPoints[3], aWPoints[5]) && OC_TriangleRasterize(aSSPoints[0], aSSPoints[3], aSSPoints[5], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[0], aWPoints[1], aWPoints[3]) && OC_TriangleRasterize(aSSPoints[0], aSSPoints[1], aSSPoints[3], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[1], aWPoints[6], aWPoints[3]) && OC_TriangleRasterize(aSSPoints[1], aSSPoints[6], aSSPoints[3], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[5], aWPoints[4], aWPoints[2]) && OC_TriangleRasterize(aSSPoints[5], aSSPoints[4], aSSPoints[2], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[4], aWPoints[5], aWPoints[7]) && OC_TriangleRasterize(aSSPoints[4], aSSPoints[5], aSSPoints[7], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[0], aWPoints[2], aWPoints[1]) && OC_TriangleRasterize(aSSPoints[0], aSSPoints[2], aSSPoints[1], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[1], aWPoints[2], aWPoints[4]) && OC_TriangleRasterize(aSSPoints[1], aSSPoints[2], aSSPoints[4], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[6], aWPoints[5], aWPoints[3]) && OC_TriangleRasterize(aSSPoints[6], aSSPoints[5], aSSPoints[3], false, aSSPoints[0], vNearFar)) || - (OC_FrustumCulling(aWPoints[5], aWPoints[6], aWPoints[7]) && OC_TriangleRasterize(aSSPoints[5], aSSPoints[6], aSSPoints[7], false, aSSPoints[0], vNearFar)) - ); - - return isVisible; + return g_pOC->comVisible(pMax, pMin); } //########################################################################## diff --git a/source/gcore/sxgcore.h b/source/gcore/sxgcore.h index 89e642eb8c9e95b48011cd64759880d47b4ae4bc..72730412f59998c0a69886f9a3cf05fa23506c3b 100644 --- a/source/gcore/sxgcore.h +++ b/source/gcore/sxgcore.h @@ -221,6 +221,60 @@ SX_LIB_API bool SGCore_MtlGroupRenderIsSingly(ID id); //!@} +//############################################################################# + +/*! \defgroup sxgcore_ds Render targets для deferred shading +\ingroup sxgcore +@{*/ + +//! типы render targets +enum DS_RT +{ + //! цвет rgba8 + DS_RT_COLOR = 0, + + //! нормали (включая микрорельеф) rfb10a2 + DS_RT_NORMAL, + + //! параметры освещения rgba8 + DS_RT_PARAM, + + //! глубина r16f, непрозрачные материалы + DS_RT_DEPTH, + + //! глубина r16f, непрозрачные материалы + DS_RT_DEPTH0, + + //! глубина r16f, непрозрачные и полупрозрачные пиксели, однако прозрачные (если есть) будут перекрывать непрозрачные, и в этом случае их глубина будет 1 то есть максимальной(для идентификации) + DS_RT_DEPTH1, + + + //! эмбиент цвет (цвет света rgb) и диффузное освещение (a) rgba16f + DS_RT_AMBIENTDIFF, + + //! блики r16f + DS_RT_SPECULAR, + + //! освещенная сцена rgba16 + DS_RT_SCENELIGHT, + + //! освещенная сцена rgba16 + DS_RT_SCENELIGHT2, + + //! текущий rt адаптации глаза к освещению r16f + DS_RT_ADAPTEDLUM +}; + +//! id render target по его типу +SX_LIB_API ID SGCore_GbufferGetRT_ID(DS_RT type); + +//! текстура render target по его типу +SX_LIB_API IDirect3DTexture9* SGCore_GbufferGetRT(DS_RT type); + +SX_LIB_API void SGCore_ToneMappingCom(DWORD timeDelta, float factor_adapted); + +//!@} sxgcore_ds + //########################################################################## /*! \name Переопределение функций diff --git a/source/geom/green.cpp b/source/geom/green.cpp index 4caab1a4af6999208bb766ba5883a3cd769e9344..1c6da9e5cc65fd8078751a0ebb65cc8718f79a7d 100644 --- a/source/geom/green.cpp +++ b/source/geom/green.cpp @@ -1201,6 +1201,10 @@ void CGreen::genByTex(CStaticGeom* geom, CModel* model, ID idmask, float3* min, float3 tmppos2; bool isintersect; + float3 vGeomMin, vGeomMax; + SGeom_ModelsGetMinMax(&vGeomMin, &vGeomMax); + float3 vPosMin = vGeomMin; + for (DWORD x = 0; xgetIntersectedRayY(&tmppos2); + { + vPosMin.x = tmppos2.x; + vPosMin.z = tmppos2.z; + isintersect = g_fnIntersect(&tmppos2, &vPosMin, &tmppos2); + } if (isintersect) { diff --git a/source/geom/green.h b/source/geom/green.h index 0b26a908c6bce6db995f6005570b976cf4de7897..36856e7819c7f0ce313262076e97bf6bbce48c11 100644 --- a/source/geom/green.h +++ b/source/geom/green.h @@ -18,6 +18,8 @@ See the license in LICENSE #include "static_geom.h" #include "sxgeom.h" +extern g_phy_intersect g_fnIntersect; + //########################################################################## #define GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr) \ diff --git a/source/geom/static_geom.cpp b/source/geom/static_geom.cpp index 570c7c3e31c5f995a3b065343f4d34a7166777ce..c42ab0214ce05620069554fb703fa996e3451b1f 100644 --- a/source/geom/static_geom.cpp +++ b/source/geom/static_geom.cpp @@ -2692,7 +2692,7 @@ void CStaticGeom::sortGroup(const float3* viewpos, int sort_mtl) } -void CStaticGeom::getIntersectedRayY2(float3* pos, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render) +/*void CStaticGeom::getIntersectedRayY2(float3* pos, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render) { float3 jmin, jmax; comsegment->m_pBoundVolumeP->getMinMax(&jmin, &jmax); @@ -2717,9 +2717,9 @@ void CStaticGeom::getIntersectedRayY2(float3* pos, CSegment** arrsplits, int *co } } } -} +}*/ -bool CStaticGeom::getIntersectedRayY(float3* pos) +/*bool CStaticGeom::getIntersectedRayY(float3* pos) { D3DXVECTOR3 jpos; float3 jvec0, jvec1, jvec2; @@ -2742,8 +2742,8 @@ bool CStaticGeom::getIntersectedRayY(float3* pos) { for (DWORD group = 0; groupm_aIRS[id]->m_ppSegments[k]->m_uiCountSubSet; group++) { - /*if (m_aAllGroups[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group]]->m_iSortGroup > 0) - continue;*/ + //if (m_aAllGroups[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group]]->m_iSortGroup > 0) + //continue; ID idbuff = m_aAllModels[id]->m_aSubSets[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroupModel[group]].m_idBuff; ID idgroup = m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group]; @@ -2756,14 +2756,7 @@ bool CStaticGeom::getIntersectedRayY(float3* pos) { Dist = -1000.f; //находим все 3 вершины - /*jvec0 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]]; - jvec1 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]]; - jvec2 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]];*/ - //jvec0 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]]; - //jvec1 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]]; - //jvec2 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]]; - jvec0 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]].Pos; jvec1 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]].Pos; jvec2 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]].Pos; @@ -2801,7 +2794,7 @@ bool CStaticGeom::getIntersectedRayY(float3* pos) } pos->y = tmpy; return is_find; -} +}*/ void CStaticGeom::getMinMax(float3* min, float3* max) { diff --git a/source/geom/static_geom.h b/source/geom/static_geom.h index 966b6c4d0a5fd7074cfe3054019a6eb79c5144ab..f488506b92fceacf4ea24d23d106b56d0484c12d 100644 --- a/source/geom/static_geom.h +++ b/source/geom/static_geom.h @@ -356,7 +356,7 @@ public: int getCountModel(); void comArrIndeces(const IFrustum *pFrustum, const float3 *pViewPos, ID idArr = 0); - bool getIntersectedRayY(float3 *pPos); + //bool getIntersectedRayY(float3 *pPos); bool sortExistsForRender(int iSortMtl, ID idArr = 0); diff --git a/source/geom/sxgeom.cpp b/source/geom/sxgeom.cpp index 500fb5749a59a7c8ef1baf7b065e6c66ad4cbb3d..31f9fb71e78ba652a7d6c6e67e506b040b04f4aa 100644 --- a/source/geom/sxgeom.cpp +++ b/source/geom/sxgeom.cpp @@ -400,6 +400,18 @@ SX_LIB_API bool SGeom_ModelsTraceBeam(const float3 *pStart, const float3 *pDir, //########################################################################## +bool StdFuncIntersect(const float3 *pStart, const float3 *pEnd, float3 *pResult) +{ + return false; +} + +g_phy_intersect g_fnIntersect = StdFuncIntersect; + +SX_LIB_API void SGeom_GreenSetFncIntersect(g_phy_intersect fnFunc) +{ + g_fnIntersect = fnFunc; +} + SX_LIB_API ID SGeom_GreenAddGreen( const char *szName, const char *szPathMask, diff --git a/source/geom/sxgeom.h b/source/geom/sxgeom.h index 818c29a060972a7707b5f1e1c193917c072ed7ac..6ed5f3f42d7ff7de225da9215df0990032daf470 100644 --- a/source/geom/sxgeom.h +++ b/source/geom/sxgeom.h @@ -405,6 +405,10 @@ SX_LIB_API bool SGeom_ModelsTraceBeam( #define GREEN_GEN_RAND_SCALE 1.f /*!< рандомный масштаб модели при генерации (0, 1 + GREEN_GEN_RAND_SCALE) */ #define GREEN_GEN_RAND_ROTATE_Y SM_2PI /*!< рандомный поворот (в радианах) модели при генерации (0, 1 + GREEN_GEN_RAND_ROTATE_Y) */ +typedef bool(*g_phy_intersect)(const float3 *pStart, const float3 *pFinish, float3 *pResult); + +SX_LIB_API void SGeom_GreenSetFncIntersect(g_phy_intersect fnFunc); + //! типы растительности enum GREEN_TYPE { diff --git a/source/level/level.cpp b/source/level/level.cpp index 4b12ab34a07277ed3fa7cb0e0a85ae0acc3d246c..141bc9ded94af60c440083b0e3271fff91f72fc5 100644 --- a/source/level/level.cpp +++ b/source/level/level.cpp @@ -34,7 +34,7 @@ void CLevel::clear() SGeom_ModelsClear(); SGeom_GreenClear(); - SML_LigthsClearIDArr(); + SLight_ClearIDArr(); //SXGame_UnloadObjLevel(); Core_0ConsoleExecCmd("ent_unload_level"); @@ -189,14 +189,14 @@ void CLevel::load(const char *szName, bool isGame) SGeom_ModelsGetMinMax(&vMin, &vMax); SGCore_SkyCloudsSetWidthHeightPos((vMax.x - vMin.x) * 2.f, (vMax.z - vMin.z) * 2.f, &float3((vMax + vMin) * 0.5)); - ID gid = SML_LigthsCreatePoint( + ID gid = SLight_CreatePoint( &float3(60, 60, 0), 0, &float3(1, 1, 1), true, true); - SML_LigthsSetEnable(gid, true); - SML_LigthsSetName(gid, "sun"); + SLight_SetEnable(gid, true); + SLight_SetName(gid, "sun"); } } @@ -235,7 +235,7 @@ void CLevel::save(const char *szName) SGeom_GreenSave(tmppathlevel); } - if (SML_LigthsGetGlobal() > 0) + if (SLight_GetGlobal() > 0) fprintf(file, "type = outdoor\n"); else fprintf(file, "type = indoor\n"); diff --git a/source/level/weather.cpp b/source/level/weather.cpp index dddc24a338ba84b0fc1415b32f3e927d02b7aebc..aabd62da45265a33612c7f425d62f5318eae36b9 100644 --- a/source/level/weather.cpp +++ b/source/level/weather.cpp @@ -174,8 +174,8 @@ CWeather::CWeather() } m_ulTimeBoltNext = m_ulTimeBoltLast = 0; - m_idLightThunderbolt = SML_LigthsCreatePoint(&float3(0, 0, 0), 200, &float3(1, 1, 1), false, true); - SML_LigthsSetEnable(m_idLightThunderbolt, false); + m_idLightThunderbolt = SLight_CreatePoint(&float3(0, 0, 0), 200, &float3(1, 1, 1), false, true); + SLight_SetEnable(m_idLightThunderbolt, false); m_idSndRain = SSCore_SndCreate2d("nature/rain.ogg", SX_SOUND_CHANNEL_GAME, true); m_idSndThunder = SSCore_SndCreate2d("nature/thunder.ogg", SX_SOUND_CHANNEL_GAME); @@ -185,7 +185,7 @@ CWeather::CWeather() CWeather::~CWeather() { m_aTimeSections.clear(); - SML_LigthsDeleteLight(m_idLightThunderbolt); + SLight_DeleteLight(m_idLightThunderbolt); SSCore_SndDelete(m_idSndRain); SSCore_SndDelete(m_idSndThunder); } @@ -217,7 +217,7 @@ void CWeather::load(const char *szPath) SSCore_SndStop(m_idSndRain); SPE_EffectEnableSet(m_idEffThunderbolt, false); - SML_LigthsSetEnable(m_idLightThunderbolt, false); + SLight_SetEnable(m_idLightThunderbolt, false); SSCore_SndStop(m_idSndThunder); m_aTimeSections.clear(); @@ -562,7 +562,7 @@ void CWeather::update() if (m_isPlaying) m_RndSnd.update(); - ID gid = SML_LigthsGetGlobal(); + ID gid = SLight_GetGlobal(); static const float * env_weather_snd_volume = GET_PCVAR_FLOAT("env_weather_snd_volume"); @@ -631,10 +631,10 @@ void CWeather::update() if (gid >= 0) { //установка/сброс состояния включения - SML_LigthsSetEnable(gid, pStrSunTex[0] != '0'); + SLight_SetEnable(gid, pStrSunTex[0] != '0'); //установка/сброс состояния "все в тени от глобального источника" - SML_LigthsSetCastGlobalShadow(pStrSunTex[0] == '1'); + SLight_SetCastGlobalShadow(pStrSunTex[0] == '1'); } m_hasUpdate = true; @@ -720,14 +720,14 @@ void CWeather::update() tmp_scolor.x = lerpf(m_aTimeSections[m_iSectionOld].m_DataSection.m_vSunColor.x, m_aTimeSections[m_iSectionCurr].m_DataSection.m_vSunColor.x, lerp_factor); tmp_scolor.y = lerpf(m_aTimeSections[m_iSectionOld].m_DataSection.m_vSunColor.y, m_aTimeSections[m_iSectionCurr].m_DataSection.m_vSunColor.y, lerp_factor); tmp_scolor.z = lerpf(m_aTimeSections[m_iSectionOld].m_DataSection.m_vSunColor.z, m_aTimeSections[m_iSectionCurr].m_DataSection.m_vSunColor.z, lerp_factor); - SML_LigthsSetColor(gid, &tmp_scolor); + SLight_SetColor(gid, &tmp_scolor); //позици¤ солнца float3 tmp_spos; tmp_spos.x = lerpf(m_aTimeSections[m_iSectionOld].m_DataSection.m_vSunPos.x, m_aTimeSections[m_iSectionCurr].m_DataSection.m_vSunPos.x, lerp_factor); tmp_spos.y = lerpf(m_aTimeSections[m_iSectionOld].m_DataSection.m_vSunPos.y, m_aTimeSections[m_iSectionCurr].m_DataSection.m_vSunPos.y, lerp_factor); tmp_spos.z = 0; - SML_LigthsSetPos(gid, &tmp_spos, false); + SLight_SetPos(gid, &tmp_spos, false); } //дальность видимости @@ -774,8 +774,8 @@ void CWeather::update() float3 tpos = float3(randf(m_vBoltMin.x, m_vBoltMax.x), randf(m_vBoltMin.y, m_vBoltMax.y), randf(m_vBoltMin.z, m_vBoltMax.z)); SPE_EffectPosSet(m_idEffThunderbolt, &tpos); SPE_EffectEnableSet(m_idEffThunderbolt, true); - SML_LigthsSetPos(m_idLightThunderbolt, &tpos, false); - SML_LigthsSetEnable(m_idLightThunderbolt, true); + SLight_SetPos(m_idLightThunderbolt, &tpos, false); + SLight_SetEnable(m_idLightThunderbolt, true); m_ulTimeBoltLight = TimeGetMls(Core_RIntGet(G_RI_INT_TIMER_RENDER)); } else @@ -803,7 +803,7 @@ void CWeather::update() if (m_ulTimeBoltLight > 0 && TimeGetMls(Core_RIntGet(G_RI_INT_TIMER_RENDER)) - m_ulTimeBoltLight > WEATHER_THUNDERBOLT_LIGHT_TIME) { m_ulTimeBoltLight = 0; - SML_LigthsSetEnable(m_idLightThunderbolt, false); + SLight_SetEnable(m_idLightThunderbolt, false); //и заодно проиграть звук молнии SSCore_SndSetPosPlay(m_idSndThunder, 0); diff --git a/source/mtllight/light.cpp b/source/light/light.cpp similarity index 87% rename from source/mtllight/light.cpp rename to source/light/light.cpp index bb8055222d30422112308bdfd023051800522621..c77a78961059c99b98ab7bfc1ddb4023fe429569 100644 --- a/source/mtllight/light.cpp +++ b/source/light/light.cpp @@ -1328,7 +1328,7 @@ void CLights::shadowSoft(bool randomsam, float size, bool isfirst) SGCore_SetSamplerFilter(1, D3DTEXF_POINT); SGCore_SetSamplerAddress(1, D3DTADDRESS_CLAMP); - MLSet::DXDevice->SetTexture(0,SGCore_RTGetTexture(MLSet::IDsRenderTargets::DepthScene)); + MLSet::DXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_DEPTH)); if(HowShadow == 0) MLSet::DXDevice->SetTexture(1, SGCore_RTGetTexture(ShadowMap)); @@ -1374,128 +1374,6 @@ void CLights::shadowSoft(bool randomsam, float size, bool isfirst) HowShadow = 1; } -void CLights::toneMappingCom(DWORD timeDelta, float factor_adapted) -{ - static const int *r_win_width = GET_PCVAR_INT("r_win_width"); - static const int *r_win_height = GET_PCVAR_INT("r_win_height"); - - MLSet::GetArrDownScale4x4(*r_win_width, *r_win_height, MLSet::HDRSampleOffsets); - - LPDIRECT3DSURFACE9 SurfSceneScale, BackBuf; - - SGCore_RTGetTexture(MLSet::IDsRenderTargets::LigthComScaled)->GetSurfaceLevel(0, &SurfSceneScale); - - MLSet::DXDevice->GetRenderTarget(0, &BackBuf); - MLSet::DXDevice->SetRenderTarget(0, SurfSceneScale); - - SGCore_ShaderBind(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::SampleLumIterative); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::SampleLumIterative, "g_aOffsets", &(MLSet::HDRSampleOffsets)); - - MLSet::DXDevice->SetTexture(0, SGCore_RTGetTexture(MLSet::IDsRenderTargets::LigthCom)); - SGCore_ScreenQuadDraw(); - - SGCore_ShaderUnBind(); - - mem_release(SurfSceneScale); - - MLSet::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED); - int CurrTexture = MLSet::IDsRenderTargets::CountArrToneMaps - 1; - - for (int i = 0; i < MLSet::IDsRenderTargets::CountArrToneMaps; i++) - { - IDirect3DTexture9* tmptex = SGCore_RTGetTexture(MLSet::IDsRenderTargets::ToneMaps[i]); - IDirect3DSurface9* tmpsurf = MLSet::IDsRenderTargets::SurfToneMap[i]; - SGCore_RTGetTexture(MLSet::IDsRenderTargets::ToneMaps[i])->GetSurfaceLevel(0, &MLSet::IDsRenderTargets::SurfToneMap[i]); - int qwert = 0; - } - - D3DSURFACE_DESC desc; - SGCore_RTGetTexture(MLSet::IDsRenderTargets::ToneMaps[CurrTexture])->GetLevelDesc(0, &desc); - - MLSet::GetArrDownScale4x4(desc.Width, desc.Height, MLSet::HDRSampleOffsets); - - MLSet::DXDevice->SetRenderTarget(0, MLSet::IDsRenderTargets::SurfToneMap[CurrTexture]); - MLSet::DXDevice->SetTexture(0, SGCore_RTGetTexture(MLSet::IDsRenderTargets::LigthComScaled)); - MLSet::DXDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); - MLSet::DXDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); - MLSet::DXDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); - MLSet::DXDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); - - SGCore_ShaderBind(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::SampleLumInit); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::SampleLumInit, "g_aOffsets", &(MLSet::HDRSampleOffsets)); - - SGCore_ScreenQuadDraw(); - - SGCore_ShaderUnBind(); - mem_release(MLSet::IDsRenderTargets::SurfToneMap[CurrTexture]); - - --CurrTexture; - - - - while (CurrTexture >= 0) - { - SGCore_RTGetTexture(MLSet::IDsRenderTargets::ToneMaps[CurrTexture + 1])->GetLevelDesc(0, &desc); - MLSet::GetArrDownScale4x4(desc.Width, desc.Height, MLSet::HDRSampleOffsets); - - MLSet::DXDevice->SetRenderTarget(0, MLSet::IDsRenderTargets::SurfToneMap[CurrTexture]); - MLSet::DXDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); - MLSet::DXDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); - - SGCore_ShaderBind(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::SampleLumIterative); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::SampleLumIterative, "g_aOffsets", &(MLSet::HDRSampleOffsets)); - - MLSet::DXDevice->SetTexture(0, SGCore_RTGetTexture(MLSet::IDsRenderTargets::ToneMaps[CurrTexture + 1])); - SGCore_ScreenQuadDraw(); - - SGCore_ShaderUnBind(); - CurrTexture--; - } - - IDirect3DTexture9* tmptex = SGCore_RTGetTexture(MLSet::IDsRenderTargets::ToneMaps[3]); - - for (int i = 0; i < MLSet::IDsRenderTargets::CountArrToneMaps-1; i++) - { - IDirect3DSurface9* tmpsurf = MLSet::IDsRenderTargets::SurfToneMap[i]; - mem_release(MLSet::IDsRenderTargets::SurfToneMap[i]); - } - - tmptex = SGCore_RTGetTexture(MLSet::IDsRenderTargets::ToneMaps[3]); - - MLSet::IDsRenderTargets::IncrAdaptedLum(); - LPDIRECT3DSURFACE9 SurfAdaptedLum = NULL; - SGCore_RTGetTexture(MLSet::IDsRenderTargets::GetCurrAdaptedLum())->GetSurfaceLevel(0, &SurfAdaptedLum); - - MLSet::DXDevice->SetRenderTarget(0, SurfAdaptedLum); - MLSet::DXDevice->SetTexture(0, SGCore_RTGetTexture(MLSet::IDsRenderTargets::GetLastAdaptedLum())); - MLSet::DXDevice->SetTexture(1, SGCore_RTGetTexture(MLSet::IDsRenderTargets::ToneMaps[0])); - MLSet::DXDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); - MLSet::DXDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); - MLSet::DXDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_POINT); - MLSet::DXDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_POINT); - - SGCore_ShaderBind(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::CalcAdaptedLum); - - float ElapsedTime = float(timeDelta) * 0.001f * (factor_adapted * 1000.f); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::CalcAdaptedLum, "g_fElapsedTime", &(ElapsedTime)); - - SGCore_ScreenQuadDraw(); - - SGCore_ShaderUnBind(); - mem_release(SurfAdaptedLum); - - MLSet::DXDevice->SetRenderTarget(0, BackBuf); - mem_release(BackBuf); - - MLSet::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); - - -} - void CLights::set4Or3Splits(ID id, bool is4) { LIGHTS_PRE_COND_ID(id, _VOID); diff --git a/source/mtllight/light.h b/source/light/light.h similarity index 99% rename from source/mtllight/light.h rename to source/light/light.h index 2e63e57e7c178e27cd1391b6e014ef17e4f6ba55..1eeff1020b866d956c1feb673465999feaf8965c 100644 --- a/source/mtllight/light.h +++ b/source/light/light.h @@ -15,7 +15,7 @@ See the license in LICENSE #include #include -#include "sxmtllight.h" +#include "sxlight.h" #include "ml_data.h" #define LIGHTS_PRE_COND_ID(id,stdval) \ diff --git a/source/mtllight/ml_data.cpp b/source/light/ml_data.cpp similarity index 95% rename from source/mtllight/ml_data.cpp rename to source/light/ml_data.cpp index dbb498e2d96ebbc974e7a0479b7dd5ef18a1a696..3f2721d720178187c5b042a0c2159100aa5911cb 100644 --- a/source/mtllight/ml_data.cpp +++ b/source/light/ml_data.cpp @@ -26,8 +26,7 @@ namespace MLSet //коэфициент размера текстур дл¤ карт глубин глобального источника света float CoefSizeDepthMapForGlobal = 1; - float2_t SizeTexReflection = float2_t(MTL_REF_TEX_SIZE, MTL_REF_TEX_SIZE); - + void ReCalcSize() { static const int *r_win_width = GET_PCVAR_INT("r_win_width"); @@ -40,7 +39,7 @@ namespace MLSet SizeTexDepthLocal.y = float(*r_win_height) * CoefSizeDepthMapForLocal; } - void GetArrDownScale4x4(DWORD width, DWORD height, float2 arr[]); + //void GetArrDownScale4x4(DWORD width, DWORD height, float2 arr[]); bool IsHalfGenPCFShadowLocal = false; @@ -48,7 +47,7 @@ namespace MLSet float3 OrientedCube[6] = { float3(1, 0, 0), float3(-1, 0, 0), float3(0, 1, 0), float3(0, -1, 0), float3(0, 0, 1), float3(0, 0, -1) }; float3 UpVectorsCube[6] = { float3(0, 1, 0), float3(0, 1, 0), float3(0, 0, -1), float3(0, 0, 1), float3(0, 1, 0), float3(0, 1, 0) }; - float2 HDRSampleOffsets[16]; + //float2 HDRSampleOffsets[16]; float4x4 RefMProjPlane; float4x4 RefMProjCube; @@ -100,9 +99,9 @@ namespace MLSet ID GenShadowCube1; ID GenShadowCube6; - ID CalcAdaptedLum; + /*ID CalcAdaptedLum; ID SampleLumInit; - ID SampleLumIterative; + ID SampleLumIterative;*/ ID ScreenOut; @@ -115,7 +114,7 @@ namespace MLSet }; }; - namespace IDsRenderTargets + /*namespace IDsRenderTargets { ID DSComLight; @@ -147,7 +146,7 @@ namespace MLSet ID LigthCom3; ID LigthComScaled; - }; + };*/ namespace IDsTexs { @@ -277,10 +276,10 @@ void MLSet::MLInit() MLSet::IDsShaders::PS::PPBlurDepthBased = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_blur_depth_based.ps", "pp_blur_depth_based.ps", SHADER_CHECKDOUBLE_PATH); MLSet::IDsShaders::PS::PPBlurDepthBasedNoise = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_blur_depth_based_noise.ps", "pp_blur_depth_based_noise.ps", SHADER_CHECKDOUBLE_PATH); - MLSet::IDsShaders::PS::CalcAdaptedLum = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pptm_calc_adapted_lum.ps", "pptm_calc_adapted_lum.ps", SHADER_CHECKDOUBLE_PATH); + /*MLSet::IDsShaders::PS::CalcAdaptedLum = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pptm_calc_adapted_lum.ps", "pptm_calc_adapted_lum.ps", SHADER_CHECKDOUBLE_PATH); MLSet::IDsShaders::PS::SampleLumInit = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pptm_lum_init.ps", "pptm_lum_init.ps", SHADER_CHECKDOUBLE_PATH); MLSet::IDsShaders::PS::SampleLumIterative = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pptm_lum_iterative.ps", "pptm_lum_iterative.ps", SHADER_CHECKDOUBLE_PATH); - + */ MLSet::IDsShaders::VS::ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_quad_render.vs", "pp_quad_render.vs", SHADER_CHECKDOUBLE_PATH); MLSet::IDsShaders::PS::ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_quad_render.ps", "pp_quad_render.ps", SHADER_CHECKDOUBLE_PATH); @@ -306,15 +305,15 @@ void MLSet::MLInit() ////////// - float tmpcoefsizert = 1; + /*float tmpcoefsizert = 1; float2_t tmp_sizert = float2_t(float(*r_win_width) * tmpcoefsizert, (*r_win_height) * tmpcoefsizert); //цвет (текстуры) MLSet::IDsRenderTargets::ColorScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, "ds_color", tmpcoefsizert); //номрали + микрорельеф - MLSet::IDsRenderTargets::NormalScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8/*D3DFMT_A2R10G10B10*/, D3DPOOL_DEFAULT, "ds_normal", tmpcoefsizert); + MLSet::IDsRenderTargets::NormalScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, "ds_normal", tmpcoefsizert); //параметры освещени¤ - MLSet::IDsRenderTargets::ParamsScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, "ds_param", tmpcoefsizert); + /*MLSet::IDsRenderTargets::ParamsScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, "ds_param", tmpcoefsizert); MLSet::IDsRenderTargets::DepthScene = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "ds_depth", tmpcoefsizert); MLSet::IDsRenderTargets::DepthScene0 = SGCore_RTAdd(tmp_sizert.x, tmp_sizert.y, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, "ds_depth_0", tmpcoefsizert); @@ -352,10 +351,10 @@ void MLSet::MLInit() MLSet::IDsRenderTargets::LigthComScaled = SGCore_RTAdd(float(*r_win_width)*0.25f, float(*r_win_height)*0.25f, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, "ds_lightcomscaled", 0.25); MLSet::RefMProjPlane = SMMatrixPerspectiveFovLH(*r_default_fov, float(*r_win_width) / float(*r_win_height), MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); - MLSet::RefMProjCube = SMMatrixPerspectiveFovLH(SM_PI * 0.5f, 1, MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); + MLSet::RefMProjCube = SMMatrixPerspectiveFovLH(SM_PI * 0.5f, 1, MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR);*/ } -void MLSet::GetArrDownScale4x4(DWORD width, DWORD height, float2 arr[]) +/*void MLSet::GetArrDownScale4x4(DWORD width, DWORD height, float2 arr[]) { if (arr == 0) return; @@ -375,4 +374,4 @@ void MLSet::GetArrDownScale4x4(DWORD width, DWORD height, float2 arr[]) ++index; } } -} \ No newline at end of file +}*/ \ No newline at end of file diff --git a/source/mtllight/ml_data.h b/source/light/ml_data.h similarity index 93% rename from source/mtllight/ml_data.h rename to source/light/ml_data.h index 162c173b7aeb1f9f25407df8a679fc214d013c6c..2f06f52b495f7de146d0e5e91c4199fbc7163fb2 100644 --- a/source/mtllight/ml_data.h +++ b/source/light/ml_data.h @@ -15,7 +15,7 @@ See the license in LICENSE #include -#include "sxmtllight.h" +#include "sxlight.h" namespace MLSet { @@ -42,7 +42,7 @@ namespace MLSet void ReCalcSize(); - void GetArrDownScale4x4(DWORD width, DWORD height, float2 arr[]); + //void GetArrDownScale4x4(DWORD width, DWORD height, float2 arr[]); extern bool IsHalfGenPCFShadowLocal; @@ -51,7 +51,7 @@ namespace MLSet extern float3 OrientedCube[6]; extern float3 UpVectorsCube[6]; - extern float2 HDRSampleOffsets[16]; + //extern float2 HDRSampleOffsets[16]; extern float4x4 RefMProjPlane; extern float4x4 RefMProjCube; @@ -103,9 +103,9 @@ namespace MLSet extern ID GenShadowCube1; extern ID GenShadowCube6; - extern ID CalcAdaptedLum; + /*extern ID CalcAdaptedLum; extern ID SampleLumInit; - extern ID SampleLumIterative; + extern ID SampleLumIterative;*/ extern ID ScreenOut; @@ -118,7 +118,7 @@ namespace MLSet }; }; - namespace IDsRenderTargets + /*namespace IDsRenderTargets { extern ID DSComLight; @@ -150,7 +150,7 @@ namespace MLSet extern ID LigthCom3; extern ID LigthComScaled; - }; + };*/ namespace IDsTexs { diff --git a/source/mtllight/shadow.cpp b/source/light/shadow.cpp similarity index 98% rename from source/mtllight/shadow.cpp rename to source/light/shadow.cpp index 7f185c063a638225b81580aab30d3293497424e2..6f903017072e022687cd25e04144478153978bab 100644 --- a/source/mtllight/shadow.cpp +++ b/source/light/shadow.cpp @@ -444,8 +444,8 @@ void PSSM::genShadow(IDirect3DTexture9* shadowmap) SGCore_SetSamplerFilter2(1, 6, D3DTEXF_LINEAR); SGCore_SetSamplerAddress2(1, 6, D3DTADDRESS_CLAMP); - MLSet::DXDevice->SetTexture(0, SGCore_RTGetTexture(MLSet::IDsRenderTargets::DepthScene)); - MLSet::DXDevice->SetTexture(6, SGCore_RTGetTexture(MLSet::IDsRenderTargets::NormalScene)); + MLSet::DXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_DEPTH)); + MLSet::DXDevice->SetTexture(6, SGCore_GbufferGetRT(DS_RT_NORMAL)); float4x4 aMatrixTexture[5]; @@ -775,7 +775,7 @@ void ShadowMapTech::genShadow(IDirect3DTexture9* shadowmap) SGCore_SetSamplerFilter(2, D3DTEXF_POINT); SGCore_SetSamplerAddress(2, D3DTADDRESS_WRAP); - MLSet::DXDevice->SetTexture(0, SGCore_RTGetTexture(MLSet::IDsRenderTargets::DepthScene)); + MLSet::DXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_DEPTH)); float4x4 MatrixTexture; @@ -1118,7 +1118,7 @@ void ShadowMapCubeTech::genShadow(IDirect3DTexture9* shadowmap) SGCore_SetSamplerFilter(2, D3DTEXF_POINT); SGCore_SetSamplerAddress(2, D3DTADDRESS_WRAP); - MLSet::DXDevice->SetTexture(0, SGCore_RTGetTexture(MLSet::IDsRenderTargets::DepthScene)); + MLSet::DXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_DEPTH)); MLSet::DXDevice->SetTexture(1, DepthMap); MLSet::DXDevice->SetTexture(2, SGCore_LoadTexGetTex(MLSet::IDsTexs::Tex_NoiseTex)); diff --git a/source/mtllight/shadow.h b/source/light/shadow.h similarity index 99% rename from source/mtllight/shadow.h rename to source/light/shadow.h index 0d0e0f6a8c79c3c0501bf6a698aecff63506f559..1de77f4ae04886246ceaea2b7f2e2c069ed99405 100644 --- a/source/mtllight/shadow.h +++ b/source/light/shadow.h @@ -14,7 +14,7 @@ See the license in LICENSE #include #include #include -#include "sxmtllight.h" +#include "sxlight.h" #include "ml_data.h" class PSSM diff --git a/source/light/sxlight.cpp b/source/light/sxlight.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a243a170500c2eb02f347cad3fc6c830c19a27ee --- /dev/null +++ b/source/light/sxlight.cpp @@ -0,0 +1,556 @@ + +/*********************************************************** +Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#define SXMATERIAL_LIGTH_VERSION 1 + +#include "sxlight.h" +#include "ml_data.h" + +#include "light.h" + +#if !defined(DEF_STD_REPORT) +#define DEF_STD_REPORT +report_func g_fnReportf = DefReport; +#endif + +CLights* ArrLights = 0; + +#define ML_PRECOND(retval) if(!ArrLights){LibReport(-1, "%s - sxmtlligth is not init", GEN_MSG_LOCATION); return retval;} + +//########################################################################## + +SX_LIB_API long SLight_0GetVersion() +{ + return SXMATERIAL_LIGTH_VERSION; +} + +SX_LIB_API void SLight_Dbg_Set(report_func rf) +{ + g_fnReportf = rf; +} + +SX_LIB_API void SLight_0Create(const char *szName, bool isUnic) +{ + if (szName && strlen(szName) > 1) + { + if (isUnic) + { + HANDLE hMutex = CreateMutex(NULL, FALSE, szName); + if (GetLastError() == ERROR_ALREADY_EXISTS) + { + CloseHandle(hMutex); + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - none unic name", GEN_MSG_LOCATION); + } + else + { + MLSet::MLInit(); + MLSet::ReCalcSize(); + ArrLights = new CLights(); + } + } + else + { + MLSet::MLInit(); + MLSet::ReCalcSize(); + ArrLights = new CLights(); + } + } + else + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - not init argument [name]", GEN_MSG_LOCATION); +} + +SX_LIB_API void SLight_AKill() +{ + mem_delete(ArrLights) +} + +SX_LIB_API void SLight_OnLostDevice() +{ + ML_PRECOND(_VOID); + ArrLights->onLostDevice(); +} + +SX_LIB_API void SLight_OnResetDevice() +{ + ML_PRECOND(_VOID); + + MLSet::ReCalcSize(); + ArrLights->onResetDevice(); +} + + + +SX_LIB_API void SLight_SettLCoefSizeDepth(float fCoef) +{ + ML_PRECOND(_VOID); + + MLSet::CoefSizeDepthMapForLocal = fCoef; + MLSet::ReCalcSize(); + SLight_OnLostDevice(); + SLight_OnResetDevice(); +} + +SX_LIB_API void SLight_SettGCoefSizeDepth(float fCoef) +{ + ML_PRECOND(_VOID); + + MLSet::CoefSizeDepthMapForGlobal = fCoef; + MLSet::ReCalcSize(); + SLight_OnLostDevice(); + SLight_OnResetDevice(); + +} + +SX_LIB_API float SLight_GettLCoefSizeDepth() +{ + ML_PRECOND(-1); + + return MLSet::CoefSizeDepthMapForLocal; +} + +SX_LIB_API float SLight_GettGCoefSizeDepth() +{ + ML_PRECOND(-1); + return MLSet::CoefSizeDepthMapForGlobal; +} + +//############################################################################# + +SX_LIB_API void SLight_Clear() +{ + ML_PRECOND(_VOID); + + ArrLights->clear(); +} + +SX_LIB_API void SLight_ClearIDArr() +{ + ML_PRECOND(_VOID); + + ArrLights->clearIDArr(); +} + +SX_LIB_API int SLight_GetCount() +{ + ML_PRECOND(-1); + + return ArrLights->getCountLights(); +} + +SX_LIB_API bool SLight_GetExists(ID id) +{ + ML_PRECOND(false); + + return ArrLights->getExists(id); +} + + +SX_LIB_API ID SLight_CreatePoint(const float3 *pCenter, float fDist, const float3 *pColor, bool isGlobal, bool isShadowed/*, const char* bound_volume*/) +{ + ML_PRECOND(-1); + return ArrLights->createPoint(-1, pCenter, fDist, pColor, isGlobal, isShadowed/*, 0*/); +} + +SX_LIB_API ID SLight_CreateDirection(const float3 *pPos, float fDist, const float3 *pColor, const SMQuaternion *qOrient, float fTopRadius, float fAngle, bool isShadow/*, const char* bound_volume*/) +{ + ML_PRECOND(-1); + return ArrLights->createDirection(-1, pPos, fDist, pColor, qOrient, fTopRadius, fAngle, isShadow/*, 0*/); +} + +SX_LIB_API void SLight_Render(ID id, DWORD timeDelta) +{ + ML_PRECOND(_VOID); + ArrLights->render(id, timeDelta); +} + +SX_LIB_API ID SLight_GetGlobal() +{ + ML_PRECOND(-1); + return ArrLights->getLightGlobal(); +} + +SX_LIB_API bool SLight_GetCastGlobalShadow() +{ + ML_PRECOND(false); + return ArrLights->getCastGlobalShadow(); +} + +SX_LIB_API void SLight_SetCastGlobalShadow(bool isShadowed) +{ + ML_PRECOND(_VOID); + return ArrLights->setCastGlobalShadow(isShadowed); +} + +SX_LIB_API void SLight_GetColor(ID id, float3 *pColor) +{ + ML_PRECOND(_VOID); + ArrLights->getLightColor(id, pColor); +} + +SX_LIB_API void SLight_SetColor(ID id, const float3 *pColor) +{ + ML_PRECOND(_VOID); + ArrLights->setLightColor(id, pColor); +} + +SX_LIB_API void SLight_GetPos(ID id, float3 *pPos, bool isGreal) +{ + ML_PRECOND(_VOID); + ArrLights->getLightPos(id, pPos, isGreal); +} + +SX_LIB_API float SLight_GetPower(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getLightPower(id); +} + +SX_LIB_API float SLight_GetDist(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getLightDist(id); +} + +SX_LIB_API void SLight_SetPos(ID id, const float3 *pPos, bool isGreal) +{ + ML_PRECOND(_VOID); + ArrLights->setLightPos(id, pPos, isGreal); +} + +SX_LIB_API void SLight_GetOrient(ID id, SMQuaternion *pQ) +{ + ML_PRECOND(_VOID); + ArrLights->getLightOrient(id, pQ); +} + +SX_LIB_API void SLight_SetOrient(ID id, const SMQuaternion *pQ) +{ + ML_PRECOND(_VOID); + ArrLights->setLightOrient(id, pQ); +} + +SX_LIB_API LTYPE_LIGHT SLight_GetType(ID id) +{ + ML_PRECOND(LTYPE_LIGHT_NONE); + return ArrLights->getLightType(id); +} + +SX_LIB_API bool SLight_ComVisibleForFrustum(ID id, const IFrustum *pFrustum) +{ + ML_PRECOND(false); + return ArrLights->comVisibleForFrustum(id, pFrustum); +} + +SX_LIB_API bool SLight_GetVisibleForFrustum(ID id) +{ + ML_PRECOND(false); + return ArrLights->getVisibleForFrustum(id); +} + +SX_LIB_API float SLight_ComDistFor(ID id, const float3 *pPos) +{ + ML_PRECOND(-1); + return ArrLights->comDistFor(id, pPos); +} + +SX_LIB_API float SLight_GetDistFor(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getDistFor(id); +} + +SX_LIB_API void SLight_ComVisibleFrustumDistFor(const IFrustum *pFrustum, const float3 *pPos) +{ + ML_PRECOND(_VOID); + return ArrLights->comVisibleFrustumDistFor(pFrustum, pPos); +} + +SX_LIB_API bool SLight_GetEnable(ID id) +{ + ML_PRECOND(false); + return ArrLights->getLightEnable(id); +} + +SX_LIB_API void SLight_SetEnable(ID id, bool isEnable) +{ + ML_PRECOND(_VOID); + return ArrLights->setLightEnable(id, isEnable); +} + +SX_LIB_API bool SLight_GetShadowed(ID id) +{ + ML_PRECOND(false); + return ArrLights->getLightShadowed(id); +} + +SX_LIB_API bool SLight_Get4Or3SplitsG(ID id) +{ + ML_PRECOND(0); + return ArrLights->get4Or3Splits(id); +} + +SX_LIB_API void SLight_Set4Or3SplitsG(ID id, bool is4or3) +{ + ML_PRECOND(_VOID); + + ArrLights->set4Or3Splits(id, is4or3); +} + +SX_LIB_API IDirect3DTexture9* SLight_GetShadow() +{ + ML_PRECOND(0); + return ArrLights->getShadow2(); +} + +SX_LIB_API void SLight_ShadowNull() +{ + ML_PRECOND(_VOID); + return ArrLights->shadowNull(); +} + +SX_LIB_API void SLight_ShadowRenderBegin(ID id) +{ + ML_PRECOND(_VOID); + ArrLights->shadowRenderBegin(id); +} + +SX_LIB_API void SLight_ShadowRenderEnd(ID id) +{ + ML_PRECOND(_VOID); + ArrLights->shadowRenderEnd(id); +} + +SX_LIB_API void SLight_ShadowRenderPre(ID id, int iCube) +{ + ML_PRECOND(_VOID); + ArrLights->shadowRenderPre(id, iCube); +} + +SX_LIB_API void SLight_ShadowRenderPost(ID id, int iCube) +{ + ML_PRECOND(_VOID); + ArrLights->shadowRenderPost(id, iCube); +} + +SX_LIB_API IFrustum* SLight_GetFrustum(ID id, int iHow) +{ + ML_PRECOND(0); + return ArrLights->getLightFrustum(id, iHow); +} + +SX_LIB_API void SLight_UpdateGFrustums(ID id, int iSplit, const float3 *pPos, const float3 *pDir) +{ + ML_PRECOND(_VOID); + return ArrLights->updateLightGFrustums(id, iSplit, pPos, pDir); +} + +SX_LIB_API void SLight_ShadowSetShaderOfTypeMat(ID id, int iTypeMaterial, const float4x4 *pWorld) +{ + ML_PRECOND(_VOID); + ArrLights->initShaderOfTypeMaterial(id, iTypeMaterial, pWorld); +} + +SX_LIB_API void SLight_ShadowGen(ID id) +{ + ML_PRECOND(_VOID); + ArrLights->shadowGen2(id); +} + +SX_LIB_API void SLight_ShadowSoft(bool isRandom, float fSize, bool isFirst) +{ + ML_PRECOND(_VOID); + ArrLights->shadowSoft(isRandom, fSize, isFirst); +} + + + +SX_LIB_API ID SLight_CreateCopy(ID id) +{ + ML_PRECOND(-1); + return ArrLights->createCopy(id); +} + +SX_LIB_API void SLight_DeleteLight(ID id) +{ + ML_PRECOND(_VOID); + ArrLights->deleteLight(id); +} + +SX_LIB_API char* SLight_GetName(ID id) +{ + ML_PRECOND(0); + return ArrLights->getLightName(id); +} + +SX_LIB_API void SLight_SetName(ID id, const char *szName) +{ + ML_PRECOND(_VOID); + ArrLights->setLightName(id, szName); +} + + +SX_LIB_API void SLight_SetAngle(ID id, float fAngle) +{ + ML_PRECOND(_VOID); + ArrLights->setLightAngle(id, fAngle, true); +} + +SX_LIB_API void SLight_SetTopRadius(ID id, float fTopRadius) +{ + ML_PRECOND(_VOID); + ArrLights->setLightTopRadius(id, fTopRadius); +} + +SX_LIB_API void SLight_SetDist(ID id, float fRadiusHeight, bool isCreate) +{ + ML_PRECOND(_VOID); + ArrLights->setLightDist(id, fRadiusHeight, isCreate); +} + + +SX_LIB_API float SLight_GetShadowBias(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getShadowBias(id); +} + +SX_LIB_API void SLight_SetShadowBias(ID id, float fBias) +{ + ML_PRECOND(_VOID); + return ArrLights->setShadowBias(id, fBias); +} + +SX_LIB_API void SLight_SetShadowBlurPixel(ID id, float fBlurPixel) +{ + ML_PRECOND(_VOID); + ArrLights->setShadowBlurPixel(id, fBlurPixel); +} + +SX_LIB_API float SLight_GetShadowBlurPixel(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getShadowBlurPixel(id); +} +SX_LIB_API void SLight_SetShadowLocalNear(ID id, float fNear) +{ + ML_PRECOND(_VOID); + ArrLights->setShadowLocalNear(id, fNear); +} + +SX_LIB_API float SLight_GetShadowLocalNear(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getShadowLocalNear(id); +} + +SX_LIB_API void SLight_SetShadowLocalFar(ID id, float fFar) +{ + ML_PRECOND(_VOID); + ArrLights->setShadowLocalFar(id, fFar); +} + +SX_LIB_API float SLight_GetShadowLocalFar(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getShadowLocalFar(id); +} + +SX_LIB_API void SLight_SetCubeEdgeEnable(ID id, int iEdge, bool isEnable) +{ + ML_PRECOND(_VOID); + ArrLights->setLightCubeEdgeEnable(id, iEdge, isEnable); +} + +SX_LIB_API bool SLight_GetCubeEdgeEnable(ID id, int iEdge) +{ + ML_PRECOND(false); + return ArrLights->getLightCubeEdgeEnable(id, iEdge); +} + + +SX_LIB_API float SLight_GetAngle(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getLightAngle(id); +} + +SX_LIB_API float SLight_GetTopRadius(ID id) +{ + ML_PRECOND(-1); + return ArrLights->getLightTopRadius(id); +} + +SX_LIB_API ID SLight_GetIDArr(ID id, ID idOwner, int iHow) +{ + ML_PRECOND(-1); + return ArrLights->getLightIDArr(id, idOwner, iHow); +} + +SX_LIB_API void SLight_SetIDArr(ID id, ID idOwner, int iHow, ID idArr) +{ + ML_PRECOND(_VOID); + ArrLights->setLightIDArr(id, idOwner, iHow, idArr); +} + +SX_LIB_API void SLight_SetTypeShadowed(ID id, LTYPE_SHADOW type) +{ + ML_PRECOND(_VOID); + ArrLights->setLightTypeShadowed(id, type); +} + +SX_LIB_API LTYPE_SHADOW SLight_GetTypeShadowed(ID id) +{ + ML_PRECOND(LTYPE_SHADOW_NONE); + return ArrLights->getLightTypeShadowed(id); +} + +SX_LIB_API bool SLight_CountUpdateUpdate(ID id, const float3 *pViewPos, int iHow) +{ + ML_PRECOND(false); + return ArrLights->lightCountUpdateUpdate(id, pViewPos, iHow); +} + +SX_LIB_API bool SLight_CountUpdateAllowed(ID id, int iHow) +{ + ML_PRECOND(false); + return ArrLights->lightCountUpdateAllowed(id, iHow); +} + +SX_LIB_API void SLight_CountUpdateNull(ID id) +{ + ML_PRECOND(_VOID); + ArrLights->lightCountUpdateNull(id); +} + +/*SX_LIB_API void SLight_ToneMappingCom(DWORD timeDelta, float fAdapted) +{ + ML_PRECOND(_VOID); + ArrLights->toneMappingCom(timeDelta, fAdapted); +}*/ + +SX_LIB_API int SLight_DelGetCount() +{ + ML_PRECOND(-1); + return ArrLights->delGetCount(); +} + +SX_LIB_API LTYPE_LIGHT SLight_DelGetType(ID idKey) +{ + ML_PRECOND(LTYPE_LIGHT_NONE); + return ArrLights->delGetType(idKey); +} + +SX_LIB_API void SLight_DelDel(ID idKey) +{ + ML_PRECOND(_VOID); + ArrLights->delDel(idKey); +} + +SX_LIB_API ID SLight_DelGetIDArr(ID idKey, ID idOwner, int iHow) +{ + ML_PRECOND(-1); + return ArrLights->delGetIDArr(idKey, idOwner, iHow); +} diff --git a/source/light/sxlight.h b/source/light/sxlight.h new file mode 100644 index 0000000000000000000000000000000000000000..19cbb2eeaa84aece644e5e3107eac03fb935f28c --- /dev/null +++ b/source/light/sxlight.h @@ -0,0 +1,560 @@ + +/*********************************************************** +Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +/*! +\file +Заголовочный файл sxlight - библиотеки освещения +*/ + +/*! \defgroup sxlight sxlight - библиотека освещения +@{ +*/ + +#ifndef __SXLIGHT_H +#define __SXLIGHT_H + +#if defined(_DEBUG) +#pragma comment(lib, "sxgcore_d.lib") +#else +#pragma comment(lib, "sxgcore.lib") +#endif + +#undef SX_LIB_API +#define SX_LIB_API extern "C" __declspec (dllimport) +#include + +#ifdef SX_DLL +#undef SX_LIB_API +#define SX_LIB_API extern "C" __declspec (dllexport) +#endif + +#include + +/*! \name Базовые функции библиотеки +@{*/ + +//! версия подсистемы +SX_LIB_API long SLight_0GetVersion(); + +//! установить функцию обработки сообщений +SX_LIB_API void SLight_Dbg_Set(report_func rf); + +//! инициализция подсистемы +SX_LIB_API void SLight_0Create( + const char *szName, //!< присваиваемое имя + bool isUnic = true //!< должна ли подсистема быть уникальной по имени + ); + +//! уничтожить подсистему +SX_LIB_API void SLight_AKill(); + +//!@} + +/*! \name Обработка потери/восстановления устройства +@{*/ + +//! вызывать при потрете устройства +SX_LIB_API void SLight_OnLostDevice(); + +//! вызывать при восстановлении устройства +SX_LIB_API void SLight_OnResetDevice(); + +//!@} + +//############################################################################# + +/*! \defgroup sxlight_light Освещение + \ingroup sxlight + \warning Обращение (идентификация) конкретного света осуществляется посредством идентификатора который выдают создающие функции: + - #SLight_CreatePoint + - #SLight_CreateDirection + Получить идентификатор уже созданного света можно, посредством ключа (key) который лежит в пределах [0, #SLight_GetCount), +передав этот ключ #SLight_GetIDOfKey, которая в случае успеха вернет идентификатор света. +@{*/ + +/*! максимальное количество обновлений статических источников света, в первый момент рендера */ +#define LIGHTS_UPDATE_MAX_COUNT_FOR_STATIC 3 + +/*! \name Дистанции (метрах) при которых будет сниженно или повышено количество отрисовок для локальных источников света +меньше #LIGHTS_UPDATE_L0_DIST - обновление будет каждый кадр\n +больше #LIGHTS_UPDATE_L2_DIST - обновления не будет +@{*/ + +#define LIGHTS_UPDATE_L0_DIST 10 +#define LIGHTS_UPDATE_L1_DIST 30 +#define LIGHTS_UPDATE_L2_DIST 70 + +//!@} + +/*! Коэфициент обновления сплитов глобального света. +Cчитается: LIGHTS_UPDATE_PSSM_SPLIT*number_split + \note Первый сплит обновляется каждый кадр, второй через кадр +*/ +#define LIGHTS_UPDATE_PSSM_SPLIT 1 + +/*! аналогичнен #LIGHTS_UPDATE_PSSM_SPLIT только для 5 сплита (для теней от облаков) */ +#define LIGHTS_UPDATE_PSSM_SPLIT_5 2 + + +/*! стандартное значение верхнего/начального радиуса для направленного света */ +#define LIGHTS_LOCAL_STD_TOP_RADIUS 0.1 + +/*! стандартное значение ближней плоскости отсечения для теней локального света */ +#define LIGHTS_LOCAL_STD_NEAR 0.1 + +/*! максимальная дистанция локального света */ +#define LIGHTS_LOCAL_MAX_DIST 200.f + + +/*! радиус глобального источника */ +#define LIGHTS_GLOBAL_STD_RADIUS 999999 + +/*! отдаленность глобального света (нужно для корректности теней), если не знаете, не трогайте */ +#define LIGHTS_POS_G_MAX 1000 + + +/*! базовое направление направленноого источника света */ +#define LIGHTS_DIR_BASE float3(0, -1, 0) + + +//! типы источников света +enum LTYPE_LIGHT +{ + //! не установленный + LTYPE_LIGHT_NONE = -1, + + //! глобальный + LTYPE_LIGHT_GLOBAL, + + //! точечный + LTYPE_LIGHT_POINT, + + //! направленный + LTYPE_LIGHT_DIR +}; + +//! типы теней источников света +enum LTYPE_SHADOW +{ + //! без теней + LTYPE_SHADOW_NONE = -1, + + //! статичные тени, тень обновляется первые несколько кадров (для корректности), далее не обновляется + LTYPE_SHADOW_STATIC, + + //! полностью динамические тени + LTYPE_SHADOW_DYNAMIC, +}; + +/*! \name Настройки размеров для теней + \note Коэфициента относительно размеров окна рендера, если 1.f то размеры экрана, если 0.5f то размеры экрана * 0.5f +@{*/ + +//! установка коэфициента для локального света +SX_LIB_API void SLight_SettLCoefSizeDepth(float fCoef); + +//! установка коэфициента для глобального света +SX_LIB_API void SLight_SettGCoefSizeDepth(float fCoef); + + +//! возвращение коэфициента для локальный свет +SX_LIB_API float SLight_GettLCoefSizeDepth(); + +//! возвращение коэфициента для глобальный свет +SX_LIB_API float SLight_GettGCoefSizeDepth(); + +//!@} + +//! очистить список света +SX_LIB_API void SLight_Clear(); + +//! очистка всех идентификаторов просчетов во всех источниках света +SX_LIB_API void SLight_ClearIDArr(); + +//! общее количество света +SX_LIB_API int SLight_GetCount(); + +//! возвращает true если свет с id существует +SX_LIB_API bool SLight_GetExists(ID id); + +//! создать точечный свет (светит во все стороны) +SX_LIB_API ID SLight_CreatePoint( + const float3 *pCenter, //!< центр света (мировая позиция) + float fDist, //!< дистанция, на которую распространяется свет + const float3 *pColor, //!< цвет в пределах 0-1 + bool isGlobal, //!< глобальный ли свет (типа солнца) + bool isShadowed //!< отбрасвыает ли тени свет + ); + +//! создать направленный свет +SX_LIB_API ID SLight_CreateDirection( + const float3 *pPos, //!< позиция света (мировая) + float fDist, //!< дистанция на которую распространяется свет + const float3 *pColor, //!< цвет + const SMQuaternion *qOrient,//!< ориентация + float fTopRadius, //!< верхний (начальный) радиус + float fAngle, //!< угол (в радианах) + bool isShadow //!< отбрасвыает ли тени свет + ); + +//! возвращает тип света +SX_LIB_API LTYPE_LIGHT SLight_GetType(ID id); + +//! создать копию объекта и вернуть на нее id +SX_LIB_API ID SLight_CreateCopy(ID id); + +//! удаление света +SX_LIB_API void SLight_DeleteLight(ID id); + +//! возвращает имя света +SX_LIB_API char* SLight_GetName(ID id); + +//! устанавливает имя света +SX_LIB_API void SLight_SetName(ID id, const char *szName); + +//! отрисовка ограничивающего объема +SX_LIB_API void SLight_Render(ID id, DWORD timeDelta); + +//! в color записывает цвет света +SX_LIB_API void SLight_GetColor(ID id, float3 *pColor); + +//! устанавливает цвет света +SX_LIB_API void SLight_SetColor(ID id, const float3 *pColor); + +//! получить в pos позицию света +SX_LIB_API void SLight_GetPos( + ID id, //!< идентификатор света + float3 *pPos, //!< инициализированный вектор в который будет записана позиция + bool isReal = false //!< true - нужны реальные координаты, false - нужны углы, только для глобального света, во всех остальных случаях не имеет смысла + ); + +//! установить позицию свету +SX_LIB_API void SLight_SetPos( + ID id, //!< идентификатор света + const float3 *pPos, //!< позиция в которую будет перемещен свет + bool isReal = false //!< true - установка реальных координат, false - установка углов, только для глобального света, во всех остальных случаях не имеет смысла + ); + +//! возвращает "значение силы света" для отправки в шейдер (максимальная компонента цвет * дистанция покрытия/#LIGHTS_LOCAL_MAX_DIST) +SX_LIB_API float SLight_GetPower(ID id); + +//! возвращает дистанцию, на которую распространяется свет +SX_LIB_API float SLight_GetDist(ID id); + +//! установка новой дистанции +SX_LIB_API void SLight_SetDist( + ID id, //!< идентификатор света + float fDist, //!< новая дистанция(радиус для точечного и высота для направленного) + bool isCreate = true //!< нужно ли пересоздание объема? (если новая дистанция больше чем текущий ограничивающий объем то надо, в других случаях по усмотрению) + ); + +//! записывает в q ориентацию света +SX_LIB_API void SLight_GetOrient(ID id, SMQuaternion *pQ); + +//! установка ориентации света +SX_LIB_API void SLight_SetOrient(ID id, const SMQuaternion *pQ); + + +//! включен ли свет с идентификатором id +SX_LIB_API bool SLight_GetEnable(ID id); + +//! установить всключен (true) или отключен (false) свет с идентификатором id +SX_LIB_API void SLight_SetEnable(ID id, bool isEnable); + +//! возвращает идентификатор глобального источника света, если он есть, иначе -1 +SX_LIB_API ID SLight_GetGlobal(); + +//! возвращает установлена ли общая тень от глобального источника (все ли в тени) +SX_LIB_API bool SLight_GetCastGlobalShadow(); + +//! установить общую тень для всего от глобального источника (все в тень) +SX_LIB_API void SLight_SetCastGlobalShadow(bool isShadowed); + +//----------------------------------------------------------------------------- + +/*! \name Управление видимостью + \note Отдельный просчет - считает индивидуально для света и тут же возвращает результат просчетов + \note Предварительный просчет - просчет для всего света (к примеру в другом потоке) +@{*/ + +//! виден ли свет в данном фрустуме (отдельный просчет) +SX_LIB_API bool SLight_ComVisibleForFrustum(ID id, const IFrustum *pFrustum); + +//! дистанция от viewpos до начала света (отдельный просчет) +SX_LIB_API float SLight_ComDistFor(ID id, const float3 *pViewPos); + +//! просчет видимости и расстояния от наблюдателя viewpos до начала света, для каждого света (предварительный просчет) +SX_LIB_API void SLight_ComVisibleFrustumDistFor(const IFrustum *pFrustum, const float3 *pViewPos); + + +//! виден ли свет в просчитанном фрустуме +SX_LIB_API bool SLight_GetVisibleForFrustum(ID id); + +//! просчитанная дистанция от позиции наблюдателя до начала света +SX_LIB_API float SLight_GetDistFor(ID id); + +//!@} + +//----------------------------------------------------------------------------- + +/*! \name Настройки для направленного света +@{*/ + +//! возвращает угол, актуально только для направленного и света +SX_LIB_API float SLight_GetAngle(ID id); + +//! установить угол, актуально только для направленного и света +SX_LIB_API void SLight_SetAngle(ID id, float fAngle); + +//! возвращает верхний радиус, актуально только для направленного и света +SX_LIB_API float SLight_GetTopRadius(ID id); + +//! устанавливает верхний радиус, актуально только для направленного и света +SX_LIB_API void SLight_SetTopRadius(ID id, float fTopRadius); + +//!@} + +//----------------------------------------------------------------------------- + +/*! \name Настройки для точечного света +@{*/ + +/*! установить "рисовать ли в указанную грань cubemap тени" + \warning Актуально только когда свет может отбрасывать тени + */ +SX_LIB_API void SLight_SetCubeEdgeEnable( + ID id, //!< идентификатор света + int iEdge, //!< номер стороны/грани cubemap [0,5] + bool iEnable //!< true - рисовать, false - не рисовать + ); + +//! получить текущее значение "рисовать ли в указанную грань cubemap тени" +SX_LIB_API bool SLight_GetCubeEdgeEnable( + ID id, //!< идентификатор света + int iEdge //!< номер стороны/грани cubemap [0,5] + ); + +//!@} + +//----------------------------------------------------------------------------- + +/*! \defgroup sxlight_light_shadow Управление тенями + \ingroup sxlight_light + \note Для генерации теней используется один render target full screen + \note Для сглаживания используется еще один аналогичный render target и первый render target. При сглаживании внутри меняется только счетчик, который меняет их местами + \note Так как используется всего один render target для генерации теней то есесно в текущий момент времени можно сгенерировать и сгладить тень только для одного света + \note Для теней от глобального света используется техника PSSM (Parallel-Split Shadow Mapping) на 3/4 сплита для объектов уровня (3 или 4 сплита можно настроить #SLight_Set4Or3SplitsG) + \note Для теней от локального света используется техника Shadow Mapping в двух вариациях: + - для точечного света используется cubemap + - для направленного света - обычная техника Shadow Mapping +@{*/ + +//! отбрасывает ли свет тени +SX_LIB_API bool SLight_GetShadowed(ID id); + +//! возвращает true в случае если установлено 4 сплита для PSSM, иначе (установлено 3 сплита) false +SX_LIB_API bool SLight_Get4Or3SplitsG(ID id); + +//! установка количества сплитов (false - 3, true - 4) для PSSM +SX_LIB_API void SLight_Set4Or3SplitsG(ID id, bool is4or3); + +/*! устанавливает шейдеры и передает им данные на основании типа материала, поддерживаются все типы MTL_TYPE_*/ +SX_LIB_API void SLight_ShadowSetShaderOfTypeMat(ID id, int typemat, const float4x4 *pWorld); + +/*! \name Управление обновлениями теней + \note Так как основная задумка это real-time рендер то для этого нужны упрощения, одним из таковых является обновление теней от света, которое может происходить не каждый кадр +@{*/ + +//! установка динамики обработки теней +SX_LIB_API void SLight_SetTypeShadowed( + ID id, //!< идентификатор света + LTYPE_SHADOW type //!< значение из перечисления #LTYPE_SHADOW + ); + +//! возвращает тип динамики теней (одно из значений #LTYPE_SHADOW) +SX_LIB_API LTYPE_SHADOW SLight_GetTypeShadowed(ID id); + +//! производит обработку данных затем возвращает разрешено ли обновлять тени, увеличивает внутрений счетчик, поэтому необходимо вызывать только когда надо +SX_LIB_API bool SLight_CountUpdateUpdate( + ID id, //!< идентификатор света + const float3 *pViewPos, //!< позиция камеры для которой обновляем, на основании расстояния будет произведен расчет обновления + int iHow = -1 //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного + ); + +//! разрешено ли обновлять тени, в отличии от #SLight_UpdateCountUpdate не увеличивает внутренний счетчик +SX_LIB_API bool SLight_CountUpdateAllowed( + ID id, //!< идентификатор света + int iHow = -1 //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного + ); + +//! сбросить счетчик обновлений и обновлять до предела тени +SX_LIB_API void SLight_CountUpdateNull(ID id); + +//!@} + + +/*! \name Управление циклами рендера в карты глубин + Для локального направленного света: + \code + SLight_ShadowRenderBegin(id); + //рендер того что должно отбросить тени + SLight_ShadowRenderEnd(id); + \endcode + Для глобального и точечного: + \code + SLight_ShadowRenderBegin(id); + SLight_ShadowRenderPre(id, cube); + //рендер того что должно отбросить тени + SLight_ShadowRenderPost(id, cube); + SLight_ShadowRenderEnd(id); + \endcode + Где cube для точечного это номер стороны cubemap [0-5] в которую будет осуществлен рендер, а для глобального это номер сплита. +@{*/ + +//! подготовительные процедуры +SX_LIB_API void SLight_ShadowRenderBegin(ID id); + +//! завершающие процедуры +SX_LIB_API void SLight_ShadowRenderEnd(ID id); + +//! подготовительные процедур перед рендером для сплита/стороны +SX_LIB_API void SLight_ShadowRenderPre( + ID id, //!< идентификатор света + int iCube //!< для точечного света - сторона cubemap [0-5] для глобального света номер сплита + ); + +//! завершающие процедур перед рендером для сплита/стороны +SX_LIB_API void SLight_ShadowRenderPost( + ID id, //!< идентификатор света + int iCube //!< для точечного света - сторона cubemap [0-5] для глобального света номер сплита + ); + +//!@} + +//! обнуление карты теней, необходимо вызывать перед генерацией теней посредством функции #SLight_GenShadow +SX_LIB_API void SLight_ShadowNull(); + +//! генерация тени на основе уже отработанной информации о затенении, перед вызовов этой функции необходимо вызывать #SLight_ShadowNull +SX_LIB_API void SLight_ShadowGen(ID id); + +//! возвращает текстуру с тенями (если вызывались функции сглаживания) то вренутся сглаженная +SX_LIB_API IDirect3DTexture9* SLight_GetShadow(); + +//! сглаживание текущей тени +SX_LIB_API void SLight_ShadowSoft( + bool isRandSam, //!< использовать ли смещение по случайному направлению + float fSize, //!< коэфициент увеличения размера пикселя для размытия + bool isFirst = false //!< впервые ли вызывается размытие для текущей тени, каждый раз когда тень еще не сглажена, но сгенерирована, нужно указывать false + ); + +//! возвращает указатель фрустума света +SX_LIB_API IFrustum* SLight_GetFrustum( + ID id, //!< идентификатор света + int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного + ); + +//! обновление фрустума глобального света +SX_LIB_API void SLight_UpdateGFrustums( + ID id, //!< идентификатор света + int iSplit, //!< номер сплита + const float3 *pPos, //!< позиция наблюдателя + const float3 *pDir //!< направление взгляда наблюдателя + ); + +/*! \name Управление настройками для генерации глубины/тени +@{*/ + +//! получить текущее смещение (bias) при генерации глубины +SX_LIB_API float SLight_GetShadowBias(ID id); + +//! установить текущее смещение (bias) при генерации глубины +SX_LIB_API void SLight_SetShadowBias(ID id, float fBias); + + +//! установить размерность размытия (в пикселя) при геренации тени +SX_LIB_API void SLight_SetShadowBlurPixel(ID id, float fBlurPixel); + +//! получить текущее значение размерности (в пикселях) при генерации тени +SX_LIB_API float SLight_GetShadowBlurPixel(ID id); + + +//! установить значение ближней плоскостью отсечения для теней (локальный свет) +SX_LIB_API void SLight_SetShadowLocalNear(ID id, float fNear); + +//! получить текущее значение ближней плоскостью отсечения для теней (локальный свет) +SX_LIB_API float SLight_GetShadowLocalNear(ID id); + +/*! установка дальней плоскостью отсечения для теней (локальный свет) + \note Иногда возникают артефакты и если отрегулировать это значение то все становится на свои места, тесты показали что в основном при ошибках, увеличение этого значения решало проблемы +*/ +SX_LIB_API void SLight_SetShadowLocalFar( + ID id, //!< идентификатор света + float fFar //!< значение дальней плоскости отсечения (дальность видимости теней), обычно это значение = дальность света + ); + +//! возвращает значение дальней плоскости отсечения (дальности видимости теней) +SX_LIB_API float SLight_GetShadowLocalFar(ID id); + +//!@} + +//----------------------------------------------------------------------------- + +/*! \name Управление массивами обработки данных для рендера (к примеру от геометрии, растительности и прочего) + Cделано для того чтобы отделить просчеты видимости (если они нужны) от рендера. + К примеру можно рассчитать видимости в одном потоке а рисовать в основном. +@{ +*/ + +//! возвращает идентификатор в случае успеха, иначе <0 +SX_LIB_API ID SLight_GetIDArr( + ID id, //!< идентификатор света + ID idOwner, //!< идентификатор объекта/системы вообще того что выдало идентификатор массива + int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного + ); + +//! установить идентификатор +SX_LIB_API void SLight_SetIDArr( + ID id, //!< идентификатор света + ID idOwner, //!< идентификатор объекта/системы вообще того что выдало идентификатор массива + int iHow, //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного + ID idArr //!< номер массива обработки от объекта который надо будет обрабатывать на видимость + ); + +//!@} + +//!@} sxlight_light_shadow + +/*! \name Функции обработки удаленного света + При удалении света он помещается в специальный массив удаленных объектов, +это связано с тем что свет может содержать в себе данные которые требуют очистки памяти вне данной реализации, +к примеру идентификаторы массивов просчетов видимости. \n + Поэтому необходимо вручную удалять (уже после удаленяи функцией #SLight_DeleteLight) удаленные объекты света. + \note Доступ к элементам массива удаленных объектов света осуществляется посредством порядкового номера в массиве (ключа key), то есть можно пройтись по массиву циклом. +@{*/ + +//! возвращает количество удаленных объектов света которые требуют удаления +SX_LIB_API int SLight_DelGetCount(); + +//! возвращает тип удаленного объекта света, значения из #LightsTypeLight +SX_LIB_API LTYPE_LIGHT SLight_DelGetType(ID key); + +//! удаляет (окончательно) удаленный объект света +SX_LIB_API void SLight_DelDel(ID key); + +//! возвращает идентификатор, если был передан, иначе <0 +SX_LIB_API ID SLight_DelGetIDArr( + ID key, //!< порядковый номер объекта света в массиве удаленного света + ID idOwner, //!< идентификатор того что выдало идентификатор массива + int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного + ); + +//!@} + +//!@} sxlight_light + +#endif + +//!@} sxlight diff --git a/source/mtllight/sxmtllight_dll.cpp b/source/light/sxlight_dll.cpp similarity index 100% rename from source/mtllight/sxmtllight_dll.cpp rename to source/light/sxlight_dll.cpp diff --git "a/source/mtllight/material - \320\272\320\276\320\277\320\270\321\217.cpp" "b/source/mtllight/material - \320\272\320\276\320\277\320\270\321\217.cpp" deleted file mode 100644 index 7a035cf3b59d4a9408218e81493e2c51918688b8..0000000000000000000000000000000000000000 --- "a/source/mtllight/material - \320\272\320\276\320\277\320\270\321\217.cpp" +++ /dev/null @@ -1,2179 +0,0 @@ - -/*********************************************************** -Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 -See the license in LICENSE -***********************************************************/ - -#include "material.h" - -CMaterials::CMaterials() -{ - CurrFirstFree = -1; - m_uiCountTimeDelta = 0; - m_uiCurrTimeDelta = 0; - m_useForceblyAlphaTest = false; - SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "mtrlgeom_base.vs", "mtrlgeom_base.vs", SHADER_CHECKDOUBLE_PATH); - SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "mtrlgeom_base.ps", "mtrlgeom_base.ps", SHADER_CHECKDOUBLE_PATH); - - SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "mtrlgreen_tree_base.vs", "mtrlgreen_tree_base.vs", SHADER_CHECKDOUBLE_PATH); - SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "mtrlgreen_grass_base.vs", "mtrlgreen_grass_base.vs", SHADER_CHECKDOUBLE_PATH); - SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "mtrlgreen_base.ps", "mtrlgreen_base.ps", SHADER_CHECKDOUBLE_PATH); - - SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "mtrlgeom_light.ps", "mtrlgeom_light.ps", SHADER_CHECKDOUBLE_PATH); - - SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "mtrlskin_base.vs", "mtrlskin_base.vs", SHADER_CHECKDOUBLE_PATH); - SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "mtrlskin_base.ps", "mtrlskin_base.ps", SHADER_CHECKDOUBLE_PATH); - - m_useCountSurface = false; - m_idCurrIdSurface = 0; - - CUnitMaterial* tmpumtl = new CUnitMaterial(); - CMaterial* tmpMtlDefaultLight = new CMaterial(); - addMaterial(tmpMtlDefaultLight); - tmpumtl->m_pMtrl = tmpMtlDefaultLight; - tmpMtlDefaultLight->m_sName = String(MTL_VIRTUAL_DIR_STD_MTL) + "_light"; - tmpMtlDefaultLight->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlgeom_base.vs"); - tmpMtlDefaultLight->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlgeom_light.ps"); - - tmpMtlDefaultLight->m_oMainGraphics.m_idMainTexture = -1; - tmpMtlDefaultLight->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = true; - - MtrlDefLight = addUnitMaterial(tmpumtl); - addName(tmpMtlDefaultLight->m_sName.c_str(), MtrlDefLight); - - - - tmpumtl = new CUnitMaterial(); - tmpMtlDefaultLight = new CMaterial(); - addMaterial(tmpMtlDefaultLight); - tmpumtl->m_pMtrl = tmpMtlDefaultLight; - tmpMtlDefaultLight->m_sName = String(MTL_VIRTUAL_DIR_STD_MTL) + "_base"; - tmpumtl->m_pMtrl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlgeom_base.vs"); - tmpumtl->m_pMtrl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlgeom_base.ps"); - tmpumtl->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorld = true; - - tmpumtl->m_pMtrl->m_oMainGraphics.m_idMainTexture = -1; - tmpumtl->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = true; - - MtrlDefStatic = addUnitMaterial(tmpumtl); - addName(tmpumtl->m_pMtrl->m_sName.c_str(), MtrlDefStatic); - - - tmpumtl = new CUnitMaterial(); - tmpMtlDefaultLight = new CMaterial(); - addMaterial(tmpMtlDefaultLight); - tmpumtl->m_pMtrl = tmpMtlDefaultLight; - tmpMtlDefaultLight->m_sName = String(MTL_VIRTUAL_DIR_STD_MTL) + "_tree"; - tmpumtl->m_pMtrl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlgreen_tree_base.vs"); - tmpumtl->m_pMtrl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlgreen_base.ps"); - - tmpumtl->m_pMtrl->m_oMainGraphics.m_idMainTexture = -1; - tmpumtl->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = true; - - MtrlDefTree = addUnitMaterial(tmpumtl); - addName(tmpumtl->m_pMtrl->m_sName.c_str(), MtrlDefTree); - - - tmpumtl = new CUnitMaterial(); - tmpMtlDefaultLight = new CMaterial(); - addMaterial(tmpMtlDefaultLight); - tmpumtl->m_pMtrl = tmpMtlDefaultLight; - tmpMtlDefaultLight->m_sName = String(MTL_VIRTUAL_DIR_STD_MTL) + "_grass"; - tmpumtl->m_pMtrl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlgreen_grass_base.vs"); - tmpumtl->m_pMtrl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlgreen_base.ps"); - - tmpumtl->m_pMtrl->m_oMainGraphics.m_idMainTexture = -1; - tmpumtl->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = true; - - MtrlDefGrass = addUnitMaterial(tmpumtl); - addName(tmpumtl->m_pMtrl->m_sName.c_str(), MtrlDefGrass); - - - /*tmpumtl = new UnitMaterial(); - tmpMtlDefaultLight = new CMaterial(); - tmpumtl->m_pMtrl = tmpMtlDefaultLight; - sprintf(tmpMtlDefaultLight->Name, "%s", "mtrldef_skin"); - tmpumtl->m_pMtrl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(0, "mtrlskin_base.vs"); - tmpumtl->m_pMtrl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(1, "mtrlskin_base.ps"); - tmpumtl->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorld = true; - - tmpumtl->m_pMtrl->m_oMainGraphics.m_idMainTexture = -1; - tmpumtl->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = true; - - m_aUnitMtrls.push_back(tmpumtl); - AddName(tmpumtl->m_pMtrl->Name, m_aUnitMtrls.size() - 1); - MtrlDefSkin = m_aUnitMtrls.size() - 1;*/ - - BeginNonDef = m_aUnitMtrls.size(); -} - -CMaterials::~CMaterials() -{ - for (int i = 0; i < m_aMtrlPathes.size(); ++i) - { - for (int k = 0; k < m_aMtrlPathes[i]->m_aObjects.size(); ++k) - { - mem_delete(m_aMtrlPathes[i]->m_aObjects[k]); - } - - mem_delete(m_aMtrlPathes[i]); - } - - for (int i = 0; i < m_aUnitMtrls.size(); ++i) - { - mem_delete(m_aUnitMtrls[i]); - } - - for (int i = 0; i < m_aMtrls.size(); ++i) - { - mem_delete(m_aMtrls[i]); - } -} - -//************************************************************************** - -CMaterials::CMaterial::CMaterial() -{ - nulling(); -} - -void CMaterials::CMaterial::nulling() -{ - m_sName = ""; - - m_isDelete = false; - - m_oMainGraphics.m_idMainTexture = -1; - m_oMainGraphics.m_idShaderVS = -1; - m_oMainGraphics.m_idShaderPS = -1; - - m_oMicroDetail = CMaskDetailMicroRelief(); - m_oLightParam = CLightParam(); - - m_oMainGraphics = CMainGraphics(); - - m_oPhysics = CPhysics(); -} - -CMaterials::CMaterial::~CMaterial() -{ - if (m_oMainGraphics.m_idMainTexture >= 0) - SGCore_LoadTexDelete(m_oMainGraphics.m_idMainTexture); - - if (m_oLightParam.m_idTexParam >= 0) - SGCore_LoadTexDelete(m_oLightParam.m_idTexParam); - - if (m_oLightParam.m_idTexParamHand >= 0) - SGCore_LoadTexDelete(m_oLightParam.m_idTexParamHand); - - if (m_oMicroDetail.m_idMask >= 0) - SGCore_LoadTexDelete(m_oMicroDetail.m_idMask); - - for (int i = 0; i < 4; ++i) - { - if (m_oMicroDetail.m_aDetail[i] >= 0) - SGCore_LoadTexDelete(m_oMicroDetail.m_aDetail[i]); - - if (m_oMicroDetail.m_aMicroRelief[i] >= 0) - SGCore_LoadTexDelete(m_oMicroDetail.m_aMicroRelief[i]); - } -} - -//************************************************************************** - -CMaterials::CMaterial::CMainGraphics::CMainGraphics() -{ - m_idMainTexture = -1; - m_idShaderVS = -1; - m_idShaderPS = -1; - m_isUnlit = false; - m_useAlphaTest = false; - type_model = MTLTYPE_MODEL::MTLTYPE_MODEL_DEFAULT; - m_oDataVS = CMainGraphics::СDataShader(); - m_oDataPS = CMainGraphics::СDataShader(); - m_oDataVS.m_isTransUserDataInOtherShader = false; - m_oDataPS.m_isTransUserDataInOtherShader = false; -}; - -CMaterials::CMaterial::CMainGraphics::~CMainGraphics() -{ - -}; - -//************************************************************************** - -CMaterials::CMaterial::CMainGraphics::СDataShader::СDataShader() -{ - m_isTransWorld = false; - m_isTransView = false; - m_isTransProjection = false; - m_isTransWorldView = false; - m_isTransWorldViewProjection = false; - m_isTransPosCam = false; - m_isTransTimeDelta = false; - m_isTransUserData = false; - m_isTransWinSize = false; - m_vUserData = float4(0, 0, 0, 0); -}; - -CMaterials::CMaterial::CMainGraphics::СDataShader::~СDataShader() -{ - -}; - -//************************************************************************** - -CMaterials::CMaterial::CLightParam::CLightParam() -{ - m_idTexParam = -1; - m_idTexParamHand = -1; - - m_fRoughness = 0.f; - m_fF0 = 0.f; - m_fThickness = 1.f; - m_type_transparency = MTLTYPE_TRANSPARENCY_NONE; - - m_type_reflect = MTLTYPE_REFLECT_NONE; - m_isTextureParam = true; -} - -CMaterials::CMaterial::CLightParam::~CLightParam() -{ - -} - -//************************************************************************** - -CMaterials::CMaterial::CMaskDetailMicroRelief::CMaskDetailMicroRelief() -{ - m_idMask = -1; - m_aDetail[0] = -1; - m_aDetail[1] = -1; - m_aDetail[2] = -1; - m_aDetail[3] = -1; - - m_aMicroRelief[0] = -1; - m_aMicroRelief[1] = -1; - m_aMicroRelief[2] = -1; - m_aMicroRelief[3] = -1; -} - -CMaterials::CMaterial::CMaskDetailMicroRelief::~CMaskDetailMicroRelief() -{ - -} - -//************************************************************************** - -CMaterials::CMaterial::CPhysics::CPhysics() -{ - type_physics = MTLTYPE_PHYSIC_CONCRETE; - - m_fDurability = 10.f; - m_fHitChance = 1.f; - m_fDensity = 1000; -} - -CMaterials::CMaterial::CPhysics::~CPhysics() -{ - -} - -//************************************************************************** - -CMaterials::CUnitMaterial::CUnitMaterial() -{ - m_pMtrl = 0; - m_pReflect = 0; -} - -CMaterials::CUnitMaterial::~CUnitMaterial() -{ - m_pMtrl->m_isDelete = true; - m_pReflect = 0; - //mem_delete(Reflect); -} - -//########################################################################## - -ID CMaterials::exists(const char* name) -{ - char tmp_path[MTL_MAX_SIZE_DIR];//папка - char tmp_name[MTL_MAX_SIZE_NAME];//само имя текстыр с расширением - int id = -1; - bool IsTruePath = false; - //обрезаем имя текстуры и папку - for (int i = 0; im_sPath.c_str(), tmp_path) == 0) - { - tmpkey = i; - break; - } - } - - //если мы не нашли совпадений значит путь уникален ... - if (tmpkey == -1) - { - return -1; - } - - //проверяем записано ли уже имя текстуры - for (int i = 0; im_aObjects.size(); i++) - { - if (strcmp(m_aMtrlPathes[tmpkey]->m_aObjects[i]->m_sName.c_str(), tmp_name) == 0) - { - id = m_aMtrlPathes[tmpkey]->m_aObjects[i]->m_id; - break; - } - } - - return id; -} - -ID CMaterials::addUnitMaterial(CUnitMaterial* umtl) -{ - ID tmpid = -1; - if (CurrFirstFree + 1 == m_aUnitMtrls.size()) - { - m_aUnitMtrls.push_back(umtl); - CurrFirstFree = tmpid = m_aUnitMtrls.size() - 1; - } - else - { - if (CurrFirstFree < 0 || m_aUnitMtrls[CurrFirstFree] != 0) - { - if (CurrFirstFree < 0) - CurrFirstFree = 0; - - for (int i = CurrFirstFree; i < m_aUnitMtrls.size(); ++i) - { - if (m_aUnitMtrls[i] == 0) - { - CurrFirstFree = i; - break; - } - } - } - - m_aUnitMtrls[CurrFirstFree] = umtl; - tmpid = CurrFirstFree; - ++CurrFirstFree; - } - - return tmpid; -} - -ID CMaterials::addMaterial(CMaterial* mtl) -{ - m_aMtrls.push_back(mtl); - return m_aMtrls.size() - 1; -} - -void CMaterials::addName(const char *szName, ID id) -{ - /*char tmp_path[MTL_MAX_SIZE_DIR];//папка - char tmp_name[MTL_MAX_SIZE_NAME];//само имя текстыр с расширением - - bool IsTruePath = false; - //обрезаем имя текстуры и папку - for (int i = 0; im_sPath.c_str(), sDir.c_str()) == 0) - { - tmpkey = i; - break; - } - } - - //если мы не нашли совпадений значит путь уникален ... - if (tmpkey == -1) - { - tmpkey = m_aMtrlPathes.size(); - CPath* tmpntlp = new CPath(); - m_aMtrlPathes.push_back(tmpntlp); - m_aMtrlPathes[tmpkey]->m_sPath = sDir; - } - - m_aMtrlPathes[tmpkey]->m_aObjects.push_back(new CPath::CObject(id, sName.c_str())); -} - -bool CMaterials::loadMtl(const char* name, CMaterial** mtl) -{ - char* ArrRGBA[4] = { "r", "g", "b", "a" }; - - char tmpVS[256]; - char tmpPS[256]; - - char tmpMask[256]; - char tmpMicroDiff[4][256]; - char tmpDetail[4][256]; - - char tmpParamLigth[256]; - - char tmp_path[256];//папка - char tmp_name[256];//само им¤ текстыр с расширением - - bool IsTruePath = false; - //обрезаем им¤ текстуры и папку - for (int k = 0; k< strlen(name); k++) - { - if (name[k] == '_') - { - memcpy(tmp_path, name, sizeof(char)*k); - tmp_path[k] = 0; - sprintf(tmp_name, "%s", name + k + 1); - IsTruePath = true; - break; - } - } - - char path[1024]; - - for (DWORD k = 0; kkeyExists(tmp_name, "texture")) - tmpMtl->m_oMainGraphics.m_idMainTexture = SGCore_LoadTexAddName(config->getKey(tmp_name, "texture"), LOAD_TEXTURE_TYPE_LOAD); - else //если нет то тогда берем имя материала, может быть он имя текстуры, иначе будет -1 - tmpMtl->m_oMainGraphics.m_idMainTexture = SGCore_LoadTexAddName(name, LOAD_TEXTURE_TYPE_LOAD); - - tmpMtl->m_sName = tmp_name; - - tmpVS[0] = 0; - if (config->keyExists(tmp_name, "vs")) - sprintf(tmpVS, "%s", config->getKey(tmp_name, "vs")); - - tmpPS[0] = 0; - if (config->keyExists(tmp_name, "ps")) - sprintf(tmpPS, "%s", config->getKey(tmp_name, "ps")); - - - if (config->keyExists(tmp_name, "is_unlit")) - tmpMtl->m_oMainGraphics.m_isUnlit = String(config->getKey(tmp_name, "is_unlit")).toBool(); - else - tmpMtl->m_oMainGraphics.m_isUnlit = false; - - if (config->keyExists(tmp_name, "type")) - tmpMtl->m_oMainGraphics.type_model = (MTLTYPE_MODEL)String(config->getKey(tmp_name, "type")).toInt(); - else - tmpMtl->m_oMainGraphics.type_model = MTLTYPE_MODEL_DEFAULT; - - if (config->keyExists(tmp_name, "physmaterial")) - tmpMtl->m_oPhysics.type_physics = (MTLTYPE_PHYSIC)String(config->getKey(tmp_name, "physmaterial")).toInt(); - else - tmpMtl->m_oPhysics.type_physics = MTLTYPE_PHYSIC_DEFAULT; - - - if (STR_VALIDATE(tmpVS)) - tmpMtl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, tmpVS, tmpVS, SHADER_CHECKDOUBLE_PATH); - else - tmpMtl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlgeom_base.vs"); - - if (STR_VALIDATE(tmpPS)) - tmpMtl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, tmpPS, tmpPS, SHADER_CHECKDOUBLE_PATH); - else - tmpMtl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlgeom_base.ps"); - - tmpMicroDiff[0][0] = 0; - if (config->keyExists(tmp_name, "mirco_diff_r")) - sprintf(tmpMicroDiff[0], "%s", config->getKey(tmp_name, "mirco_diff_r")); - - if (tmpMicroDiff[0][0] != '0' && tmpMicroDiff[0][0] != 0) - tmpMtl->m_oMicroDetail.m_aMicroRelief[0] = SGCore_LoadTexAddName(tmpMicroDiff[0], LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_aMicroRelief[0] = -1; - - tmpMicroDiff[1][0] = 0; - if (config->keyExists(tmp_name, "mirco_diff_g")) - sprintf(tmpMicroDiff[1], "%s", config->getKey(tmp_name, "mirco_diff_g")); - if (tmpMicroDiff[1][0] != '0' && tmpMicroDiff[1][0] != 0) - tmpMtl->m_oMicroDetail.m_aMicroRelief[1] = SGCore_LoadTexAddName(tmpMicroDiff[1], LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_aMicroRelief[1] = -1; - - tmpMicroDiff[2][0] = 0; - if (config->keyExists(tmp_name, "mirco_diff_b")) - sprintf(tmpMicroDiff[2], "%s", config->getKey(tmp_name, "mirco_diff_b")); - if (tmpMicroDiff[2][0] != '0' && tmpMicroDiff[2][0] != 0) - tmpMtl->m_oMicroDetail.m_aMicroRelief[2] = SGCore_LoadTexAddName(tmpMicroDiff[2], LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_aMicroRelief[2] = -1; - - tmpMicroDiff[3][0] = 0; - if (config->keyExists(tmp_name, "mirco_diff_a")) - sprintf(tmpMicroDiff[3], "%s", config->getKey(tmp_name, "mirco_diff_a")); - if (tmpMicroDiff[3][0] != '0' && tmpMicroDiff[3][0] != 0) - tmpMtl->m_oMicroDetail.m_aMicroRelief[3] = SGCore_LoadTexAddName(tmpMicroDiff[3], LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_aMicroRelief[3] = -1; - - - tmpDetail[0][0] = 0; - if (config->keyExists(tmp_name, "detail_r")) - sprintf(tmpDetail[0], "%s", config->getKey(tmp_name, "detail_r")); - if (tmpDetail[0][0] != '0' && tmpMicroDiff[0][0] != 0) - tmpMtl->m_oMicroDetail.m_aDetail[0] = SGCore_LoadTexAddName(tmpDetail[0], LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_aDetail[0] = -1; - - tmpDetail[1][0] = 0; - if (config->keyExists(tmp_name, "detail_g")) - sprintf(tmpDetail[1], "%s", config->getKey(tmp_name, "detail_g")); - if (tmpDetail[1][0] != '0' && tmpMicroDiff[1][0] != 0) - tmpMtl->m_oMicroDetail.m_aDetail[1] = SGCore_LoadTexAddName(tmpDetail[1], LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_aDetail[1] = -1; - - tmpDetail[2][0] = 0; - if (config->keyExists(tmp_name, "detail_b")) - sprintf(tmpDetail[2], "%s", config->getKey(tmp_name, "detail_b")); - if (tmpDetail[2][0] != '0' && tmpMicroDiff[2][0] != 0) - tmpMtl->m_oMicroDetail.m_aDetail[2] = SGCore_LoadTexAddName(tmpDetail[2], LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_aDetail[2] = -1; - - tmpDetail[3][0] = 0; - if (config->keyExists(tmp_name, "detail_a")) - sprintf(tmpDetail[3], "%s", config->getKey(tmp_name, "detail_a")); - if (tmpDetail[3][0] != '0' && tmpMicroDiff[3][0] != 0) - tmpMtl->m_oMicroDetail.m_aDetail[3] = SGCore_LoadTexAddName(tmpDetail[3], LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_aDetail[3] = -1; - - tmpMask[0] = 0; - if (config->keyExists(tmp_name, "mask")) - sprintf(tmpMask, "%s", config->getKey(tmp_name, "mask")); - if (tmpMask[0] != '0' && tmpMask[0] != 0) - tmpMtl->m_oMicroDetail.m_idMask = SGCore_LoadTexAddName(tmpMask, LOAD_TEXTURE_TYPE_LOAD); - else - tmpMtl->m_oMicroDetail.m_idMask = -1; - - - tmpMtl->m_oLightParam.m_fRoughness = MTL_LIGHTING_DEFAULT_ROUGHNESS; - tmpMtl->m_oLightParam.m_fF0 = MTL_LIGHTING_DEFAULT_F0; - tmpMtl->m_oLightParam.m_fThickness = MTL_LIGHTING_DEFAULT_THICKNESS; - - if (config->keyExists(tmp_name, "roughness")) - tmpMtl->m_oLightParam.m_fRoughness = String(config->getKey(tmp_name, "roughness")).toDouble(); - - if (config->keyExists(tmp_name, "f0")) - tmpMtl->m_oLightParam.m_fF0 = String(config->getKey(tmp_name, "f0")).toDouble(); - - if (config->keyExists(tmp_name, "thickness")) - tmpMtl->m_oLightParam.m_fThickness = String(config->getKey(tmp_name, "thickness")).toDouble(); - - if (config->keyExists(tmp_name, "penetration")) - tmpMtl->m_oPhysics.m_fDurability = String(config->getKey(tmp_name, "penetration")).toDouble(); - - if (config->keyExists(tmp_name, "hit_chance")) - tmpMtl->m_oPhysics.m_fHitChance = String(config->getKey(tmp_name, "hit_chance")).toDouble(); - - if (config->keyExists(tmp_name, "density")) - tmpMtl->m_oPhysics.m_fDensity = String(config->getKey(tmp_name, "density")).toDouble(); - - tmpMtl->m_oLightParam.m_idTexParamHand = createTexParamLighting(tmpMtl->m_oLightParam.m_fRoughness, tmpMtl->m_oLightParam.m_fF0, tmpMtl->m_oLightParam.m_fThickness); - - //говорим что не установлено использовать ли текстуру или нет - int istexparam = -1; - - //если есть ключ использования текстуры то грузим - if (config->keyExists(tmp_name, "is_texture_param")) - istexparam = String(config->getKey(tmp_name, "is_texture_param")).toBool(); - - tmpParamLigth[0] = 0; - if (config->keyExists(tmp_name, "param_ligth")) - sprintf(tmpParamLigth, "%s", config->getKey(tmp_name, "param_ligth")); - - //если текстура с параметрами освещения была определена - if (tmpParamLigth[0] != '0' && tmpParamLigth[0] != 0) - { - tmpMtl->m_oLightParam.m_idTexParam = SGCore_LoadTexAddName(tmpParamLigth, LOAD_TEXTURE_TYPE_LOAD); - //если использование параметров освещения из текстуры не было определено - if (istexparam == -1) - tmpMtl->m_oLightParam.m_isTextureParam = true; - else - tmpMtl->m_oLightParam.m_isTextureParam = istexparam; - } - //если использование параметров освещения из текстуры не было определено - else if (istexparam == -1) - { - tmpMtl->m_oLightParam.m_isTextureParam = false; - } - - - if (config->keyExists(tmp_name, "refraction")) - tmpMtl->m_oLightParam.m_type_transparency = (MTLTYPE_TRANSPARENCY)String(config->getKey(tmp_name, "refraction")).toInt(); - else - tmpMtl->m_oLightParam.m_type_transparency = MTLTYPE_TRANSPARENCY_NONE; - - - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorld = tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransView = tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransProjection = - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorldView = tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransPosCam = - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransTimeDelta = tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWinSize = tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransUserData = false; - - if (config->keyExists(tmp_name, "vs_world")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorld = String(config->getKey(tmp_name, "vs_world")).toInt(); - - if (config->keyExists(tmp_name, "vs_view")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransView = String(config->getKey(tmp_name, "vs_view")).toInt(); - - if (config->keyExists(tmp_name, "vs_projection")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransProjection = String(config->getKey(tmp_name, "vs_projection")).toInt(); - - if (config->keyExists(tmp_name, "vs_worldview")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorldView = String(config->getKey(tmp_name, "vs_worldview")).toInt(); - - if (config->keyExists(tmp_name, "vs_worldviewprojection")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = String(config->getKey(tmp_name, "vs_worldviewprojection")).toInt(); - - if (config->keyExists(tmp_name, "vs_poscam")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransPosCam = String(config->getKey(tmp_name, "vs_poscam")).toInt(); - - if (config->keyExists(tmp_name, "vs_timedelta")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransTimeDelta = String(config->getKey(tmp_name, "vs_timedelta")).toInt(); - - if (config->keyExists(tmp_name, "vs_winsize")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWinSize = String(config->getKey(tmp_name, "vs_winsize")).toInt(); - - if (config->keyExists(tmp_name, "vs_userdata")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransUserData = String(config->getKey(tmp_name, "vs_userdata")).toInt(); - - - tmpMtl->m_oMainGraphics.m_oDataVS.m_vUserData = float4(0, 0, 0, 0); - if (config->keyExists(tmp_name, "vs_userdata_value_x")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_vUserData.x = String(config->getKey(tmp_name, "vs_userdata_value_x")).toDouble(); - - if (config->keyExists(tmp_name, "vs_userdata_value_y")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_vUserData.y = String(config->getKey(tmp_name, "vs_userdata_value_y")).toDouble(); - - if (config->keyExists(tmp_name, "vs_userdata_value_z")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_vUserData.z = String(config->getKey(tmp_name, "vs_userdata_value_z")).toDouble(); - - if (config->keyExists(tmp_name, "vs_userdata_value_w")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_vUserData.w = String(config->getKey(tmp_name, "vs_userdata_value_w")).toDouble(); - - if (config->keyExists(tmp_name, "vs_userdata_trans_in_ps")) - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransUserDataInOtherShader = String(config->getKey(tmp_name, "vs_userdata_trans_in_ps")).toBool(); - else - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransUserDataInOtherShader = false; - - - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransWorld = tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransView = tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransProjection = - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransWorldView = tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection = tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransPosCam = - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransTimeDelta = tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransWinSize = tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransUserData = false; - - if (config->keyExists(tmp_name, "ps_world")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransWorld = String(config->getKey(tmp_name, "ps_world")).toInt(); - - if (config->keyExists(tmp_name, "ps_view")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransView = String(config->getKey(tmp_name, "ps_view")).toInt(); - - if (config->keyExists(tmp_name, "ps_projection")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransProjection = String(config->getKey(tmp_name, "ps_projection")).toInt(); - - if (config->keyExists(tmp_name, "ps_worldview")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransWorldView = String(config->getKey(tmp_name, "ps_worldview")).toInt(); - - if (config->keyExists(tmp_name, "ps_worldviewprojection")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection = String(config->getKey(tmp_name, "ps_worldviewprojection")).toInt(); - - if (config->keyExists(tmp_name, "ps_poscam")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransPosCam = String(config->getKey(tmp_name, "ps_poscam")).toInt(); - - if (config->keyExists(tmp_name, "ps_timedelta")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransTimeDelta = String(config->getKey(tmp_name, "ps_timedelta")).toInt(); - - if (config->keyExists(tmp_name, "ps_winsize")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransWinSize = String(config->getKey(tmp_name, "ps_winsize")).toInt(); - - if (config->keyExists(tmp_name, "ps_userdata")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransUserData = String(config->getKey(tmp_name, "ps_userdata")).toInt(); - - tmpMtl->m_oMainGraphics.m_oDataPS.m_vUserData = float4(0, 0, 0, 0); - - if (config->keyExists(tmp_name, "ps_userdata_value_x")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_vUserData.x = String(config->getKey(tmp_name, "ps_userdata_value_x")).toDouble(); - - if (config->keyExists(tmp_name, "ps_userdata_value_y")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_vUserData.y = String(config->getKey(tmp_name, "ps_userdata_value_y")).toDouble(); - - if (config->keyExists(tmp_name, "ps_userdata_value_z")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_vUserData.z = String(config->getKey(tmp_name, "ps_userdata_value_z")).toDouble(); - - if (config->keyExists(tmp_name, "ps_userdata_value_w")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_vUserData.w = String(config->getKey(tmp_name, "ps_userdata_value_w")).toDouble(); - - if (config->keyExists(tmp_name, "ps_userdata_trans_in_vs")) - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransUserDataInOtherShader = String(config->getKey(tmp_name, "ps_userdata_trans_in_vs")).toBool(); - else - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransUserDataInOtherShader = false; - - if (config->keyExists(tmp_name, "type_reflect")) - tmpMtl->m_oLightParam.m_type_reflect = (MTLTYPE_REFLECT)String(config->getKey(tmp_name, "type_reflect")).toInt(); - - if (config->keyExists(tmp_name, "alpha_test")) - tmpMtl->m_oMainGraphics.m_useAlphaTest = String(config->getKey(tmp_name, "alpha_test")).toBool(); - else - tmpMtl->m_oMainGraphics.m_useAlphaTest = false; - - return true; - } - - return false; -} - -ID CMaterials::createTexParamLighting(float roughness, float f0, float thickness) -{ - IDirect3DTexture9* TexMaterial; - MLSet::DXDevice->CreateTexture(1, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &TexMaterial, NULL); - D3DLOCKED_RECT LockedRect; - uint32_t tmpColor = D3DCOLOR_ARGB(0, DWORD(roughness*255.f), DWORD(f0*255.f), DWORD(thickness*255.f)); - - TexMaterial->LockRect(0, &LockedRect, 0, 0); - - uint32_t* tmpOldColor = (uint32_t*)LockedRect.pBits + 0 * LockedRect.Pitch + 0 * sizeof(uint32_t); - memcpy(tmpOldColor, &tmpColor, sizeof(uint32_t)); - - TexMaterial->UnlockRect(0); - - //SGCore_LoadTexLoadTextures(); - - char nametex[64]; - sprintf(nametex, "%c_%d_%d_%d", MTL_VIRTUAL_DIR_HAND_MTL, m_aUnitMtrls.size(), rand() % 9999, rand() % 9999); - - return SGCore_LoadTexCreate(nametex, TexMaterial); -} - -void CMaterials::createMtl(const char* name, CMaterial** mtl, MTLTYPE_MODEL type) -{ - CMaterial* tmpMtl = *mtl; - new(tmpMtl)CMaterial*; - //если такого материала не существует, то мы должны были задать примерный тип материала - tmpMtl->m_oMainGraphics.type_model = type; - //обычна¤ геометри¤ - if (type == MTLTYPE_MODEL_STATIC) - { - tmpMtl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlgeom_base.vs"); - tmpMtl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlgeom_base.ps"); - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorld = true; - } - //деревь¤ - else if (type == MTLTYPE_MODEL_TREE) - { - tmpMtl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlgreen_tree_base.vs"); - tmpMtl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlgreen_base.ps"); - //tmpMtl->RenderStates.m_oMainGraphics.m_useAlphaTest = true; - } - //трава - else if (type == MTLTYPE_MODEL_GRASS) - { - tmpMtl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlgreen_grass_base.vs"); - tmpMtl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlgreen_base.ps"); - //tmpMtl->RenderStates.m_oMainGraphics.m_useAlphaTest = true; - } - //анимационная модель - else if (type == MTLTYPE_MODEL_SKIN) - { - tmpMtl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(SHADER_TYPE_VERTEX, "mtrlskin_base.vs"); - tmpMtl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(SHADER_TYPE_PIXEL, "mtrlskin_base.ps"); - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorld = true; - } - //источник света - /*else if (type == MTL_LIGHT) - { - tmpMtl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderGetID(0, "mtrlgeom_base.vs"); - tmpMtl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderGetID(1, "mtrlgeom_light.ps"); - tmpMtl->IsForwardRender = true; - tmpMtl->m_oMainGraphics.m_oDataPS.m_isTransUserData = true; - tmpMtl->m_oMainGraphics.m_oDataPS.m_vUserData = float4(0, 0, 0, 0); - }*/ - - tmpMtl->m_oMainGraphics.m_idMainTexture = SGCore_LoadTexAddName(name, LOAD_TEXTURE_TYPE_LOAD); - tmpMtl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = true; - - tmpMtl->m_oLightParam.m_fRoughness = MTL_LIGHTING_DEFAULT_ROUGHNESS; - tmpMtl->m_oLightParam.m_fF0 = MTL_LIGHTING_DEFAULT_F0; - tmpMtl->m_oLightParam.m_fThickness = MTL_LIGHTING_DEFAULT_THICKNESS; - - tmpMtl->m_oLightParam.m_idTexParam = -1; - tmpMtl->m_oLightParam.m_isTextureParam = false; - tmpMtl->m_oLightParam.m_idTexParamHand = createTexParamLighting(tmpMtl->m_oLightParam.m_fRoughness, tmpMtl->m_oLightParam.m_fF0, tmpMtl->m_oLightParam.m_fThickness); - - //char path[1024]; - char tmp_name[256]; - bool IsTruePath = false; - - for (DWORD k = 0; km_sName = tmp_name; -} - -ID CMaterials::mtlLoad(const char* name, MTLTYPE_MODEL type) -{ - ID IsLoad = exists(name); - - if (IsLoad >= 0) - { - CUnitMaterial* tmpumtl = new CUnitMaterial(); - tmpumtl->m_pMtrl = m_aUnitMtrls[IsLoad]->m_pMtrl; - - if (m_aUnitMtrls[IsLoad]->m_pReflect){ - CUnitMaterial* tmpmtl = m_aUnitMtrls[IsLoad]; - tmpumtl->m_pReflect = new CReflection(); - tmpumtl->m_pReflect->init(m_aUnitMtrls[IsLoad]->m_pReflect->getTypeReflect()); - } - - return addUnitMaterial(tmpumtl); - } - else - { - CUnitMaterial* tmpumtl = new CUnitMaterial(); - tmpumtl->m_pMtrl = new CMaterial(); - addMaterial(tmpumtl->m_pMtrl); - if (!loadMtl(name, &(tmpumtl->m_pMtrl))) - { - createMtl(name, &(tmpumtl->m_pMtrl), type); - } - else - { - if (tmpumtl->m_pMtrl->m_oLightParam.m_type_reflect != MTLTYPE_REFLECT_NONE) - { - tmpumtl->m_pReflect = new CReflection(); - tmpumtl->m_pReflect->init(tmpumtl->m_pMtrl->m_oLightParam.m_type_reflect); - } - } - - ID tmpid = addUnitMaterial(tmpumtl); - - addName(name, tmpid); - return tmpid; - } -} - -void CMaterials::mtlReLoad(ID id, const char* name) -{ - MTL_PRE_COND_ID(id); - CUnitMaterial* tmpumtl = m_aUnitMtrls[id]; - char tmpname[1024]; - if (name == 0) - sprintf(tmpname, "%s.dds", tmpumtl->m_pMtrl->m_sName.c_str()); - else - sprintf(tmpname, "%s", name); - - tmpumtl->m_pMtrl->nulling(); - if (!loadMtl(tmpname, &(tmpumtl->m_pMtrl))) - { - createMtl(name, &(tmpumtl->m_pMtrl), tmpumtl->m_pMtrl->m_oMainGraphics.type_model); - } - else - { - if (tmpumtl->m_pMtrl->m_oLightParam.m_type_reflect != MTLTYPE_REFLECT_NONE) - { - tmpumtl->m_pReflect = new CReflection(); - tmpumtl->m_pReflect->init(tmpumtl->m_pMtrl->m_oLightParam.m_type_reflect); - } - } -} - -void CMaterials::mtlSave(ID id) -{ - MTL_PRE_COND_ID(id, _VOID); - - char* ArrRGBA[4] = { "r", "g", "b", "a" }; - - CMaterial* mtrl = m_aUnitMtrls[id]->m_pMtrl; - - String sDir = StrSubstrSpre(mtrl->m_sName.c_str(), "_"); - String sPath = String(Core_RStringGet(G_RI_STRING_PATH_GS_MTRLS)) + sDir + "/"; - - FileCreateDir(Core_RStringGet(G_RI_STRING_PATH_GS_MTRLS)); - FileCreateDir(sPath.c_str()); - sPath += FileSetStrExt(mtrl->m_sName.c_str(), ".mtl"); - - FILE* file = 0; - file = fopen(sPath.c_str(), "w"); - - fprintf(file, "[%s]\n", mtrl->m_sName.c_str()); - - char tmpPathVSName[1024]; - char tmpPathPSName[1024]; - - char tmpPathMaskName[1024]; - - SGCore_ShaderGetPath(SHADER_TYPE_VERTEX, mtrl->m_oMainGraphics.m_idShaderVS, tmpPathVSName); - SGCore_ShaderGetPath(SHADER_TYPE_PIXEL, mtrl->m_oMainGraphics.m_idShaderPS, tmpPathPSName); - - fprintf(file, "type = %d\n", mtrl->m_oMainGraphics.type_model); - fprintf(file, "is_unlit = %d\n", mtrl->m_oMainGraphics.m_isUnlit); - fprintf(file, "%s%d%s", "physmaterial = ", mtrl->m_oPhysics.type_physics, "\n"); - - fprintf(file, "%s%s%s", "vs = ", tmpPathVSName, "\n"); - fprintf(file, "%s%s%s", "ps = ", tmpPathPSName, "\n"); - - fprintf(file, "%s%d%s", "alpha_test = ", mtrl->m_oMainGraphics.m_useAlphaTest, "\n"); - - char namebasetex[256]; - namebasetex[0] = '0'; - namebasetex[1] = '\0'; - SGCore_LoadTexGetName(mtrl->m_oMainGraphics.m_idMainTexture, namebasetex); - fprintf(file, "%s%s%s", "texture = ", namebasetex, "\n"); - - if (mtrl->m_oMicroDetail.m_idMask == -1) - { - tmpPathMaskName[0] = '0'; - tmpPathMaskName[1] = 0; - } - else - SGCore_LoadTexGetName(mtrl->m_oMicroDetail.m_idMask, tmpPathMaskName); - - fprintf(file, "%s%s%s", "mask = ", tmpPathMaskName, "\n"); - - for (int k = 0; k<4; k++) - { - if (mtrl->m_oMicroDetail.m_aMicroRelief[k] == -1) - { - tmpPathMaskName[0] = '0'; - tmpPathMaskName[1] = 0; - } - else - SGCore_LoadTexGetName(mtrl->m_oMicroDetail.m_aMicroRelief[k], tmpPathMaskName); - - fprintf(file, "mirco_diff_%s = %s\n", ArrRGBA[k], tmpPathMaskName); - } - - for (int k = 0; k<4; k++) - { - if (mtrl->m_oMicroDetail.m_aDetail[k] == -1) - { - tmpPathMaskName[0] = '0'; - tmpPathMaskName[1] = 0; - } - else - SGCore_LoadTexGetName(mtrl->m_oMicroDetail.m_aDetail[k], tmpPathMaskName); - - fprintf(file, "detail_%s = %s\n", ArrRGBA[k], tmpPathMaskName); - } - - if (mtrl->m_oLightParam.m_idTexParam == -1) - { - tmpPathMaskName[0] = '0'; - tmpPathMaskName[1] = 0; - } - else - SGCore_LoadTexGetName(mtrl->m_oLightParam.m_idTexParam, tmpPathMaskName); - - if (tmpPathMaskName[0] == MTL_VIRTUAL_DIR_HAND_MTL) - sprintf(tmpPathMaskName, "0"); - else - fprintf(file, "is_texture_param = %d\n", mtrl->m_oLightParam.m_isTextureParam); - - fprintf(file, "param_ligth = %s\n", tmpPathMaskName); - - fprintf(file, "roughness = %f\n", mtrl->m_oLightParam.m_fRoughness); - fprintf(file, "f0 = %f\n", mtrl->m_oLightParam.m_fF0); - fprintf(file, "thickness = %f\n", mtrl->m_oLightParam.m_fThickness); - fprintf(file, "penetration = %f\n", mtrl->m_oPhysics.m_fDurability); - fprintf(file, "hit_chance = %f\n", mtrl->m_oPhysics.m_fHitChance); - fprintf(file, "density = %f\n", mtrl->m_oPhysics.m_fDensity); - - fprintf(file, "refraction = %d\n", mtrl->m_oLightParam.m_type_transparency); - - fprintf(file, "vs_world = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransWorld); - fprintf(file, "vs_view = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransView); - fprintf(file, "vs_projection = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransProjection); - fprintf(file, "vs_worldview = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldView); - fprintf(file, "vs_worldviewprojection = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection); - - fprintf(file, "vs_poscam = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransPosCam); - fprintf(file, "vs_timedelta = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransTimeDelta); - fprintf(file, "vs_winsize = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransWinSize); - fprintf(file, "vs_userdata = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransUserData); - fprintf(file, "vs_userdata_value_x = %f\nvs_userdata_value_y = %f\nvs_userdata_value_z = %f\nvs_userdata_value_w = %f\n", mtrl->m_oMainGraphics.m_oDataVS.m_vUserData.x, mtrl->m_oMainGraphics.m_oDataVS.m_vUserData.y, mtrl->m_oMainGraphics.m_oDataVS.m_vUserData.z, mtrl->m_oMainGraphics.m_oDataVS.m_vUserData.w); - fprintf(file, "vs_userdata_trans_in_ps = %d\n", mtrl->m_oMainGraphics.m_oDataVS.m_isTransUserDataInOtherShader); - - fprintf(file, "ps_world = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransWorld); - fprintf(file, "ps_view = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransView); - fprintf(file, "ps_projection = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransProjection); - fprintf(file, "ps_worldview = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldView); - fprintf(file, "ps_worldviewprojection = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection); - - fprintf(file, "ps_poscam = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransPosCam); - fprintf(file, "ps_timedelta = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransTimeDelta); - fprintf(file, "ps_winsize = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransWinSize); - fprintf(file, "ps_userdata = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransUserData); - fprintf(file, "ps_userdata_value_x = %f\nps_userdata_value_y = %f\nps_userdata_value_z = %f\nps_userdata_value_w = %f\n", mtrl->m_oMainGraphics.m_oDataPS.m_vUserData.x, mtrl->m_oMainGraphics.m_oDataPS.m_vUserData.y, mtrl->m_oMainGraphics.m_oDataPS.m_vUserData.z, mtrl->m_oMainGraphics.m_oDataPS.m_vUserData.w); - fprintf(file, "ps_userdata_trans_in_vs = %d\n", mtrl->m_oMainGraphics.m_oDataPS.m_isTransUserDataInOtherShader); - - fprintf(file, "type_reflect = %d\n", mtrl->m_oLightParam.m_type_reflect); - - fprintf(file, "\n"); - fclose(file); -} - -//########################################################################## - -int CMaterials::delRefCount() -{ - return m_aReflections.size(); -} - -ID CMaterials::delRefGetIDArr(ID key, ID inid, int cube) -{ - if (!(key >= 0 && key < m_aReflections.size())) - return -1; - - return m_aReflections[key]->getIDArr(inid, cube); -} - -void CMaterials::delRefAllDel() -{ - for (int i = 0; i < m_aReflections.size(); ++i) - { - mem_delete(m_aReflections[i]); - } - - m_aReflections.clear(); -} - -//########################################################################## - -void CMaterials::clear(bool isClearRefDel) -{ - int tmpcountdel = 0; - - for (int i = 0; i < m_aMtrlPathes.size(); ++i) - { - if (strcmp(m_aMtrlPathes[i]->m_sPath.c_str(), MTL_VIRTUAL_DIR_STD_MTL) != 0) - { - for (int k = 0; k < m_aMtrlPathes[i]->m_aObjects.size(); ++k) - { - mem_delete(m_aMtrlPathes[i]->m_aObjects[k]); - m_aMtrlPathes[i]->m_aObjects.erase(k); - --k; - ++tmpcountdel; - } - - if (m_aMtrlPathes.size() <= 0) - { - mem_delete(m_aMtrlPathes[i]); - m_aMtrlPathes.erase(i); - --i; - } - } - } - - tmpcountdel = 0; - - for (int i = BeginNonDef; i < m_aUnitMtrls.size(); ++i) - { - //если есть отражения, то записываем в очередь на удаление - if (m_aUnitMtrls[i]->m_pReflect) - m_aReflections.push_back(m_aUnitMtrls[i]->m_pReflect); - - mem_delete(m_aUnitMtrls[i]); - ++tmpcountdel; - } - - CurrFirstFree = BeginNonDef; - - tmpcountdel = 0; - - for (int i = 0; i < m_aMtrls.size(); ++i) - { - if (m_aMtrls[i]->m_isDelete) - { - mem_delete(m_aMtrls[i]); - m_aMtrls.erase(i); - --i; - ++tmpcountdel; - } - } - - if (isClearRefDel) - delRefAllDel(); -} - -//########################################################################## - -void CMaterials::onLostDevice() -{ - for (int i = 0; i < m_aUnitMtrls.size(); ++i) - { - if (m_aUnitMtrls[i] && m_aUnitMtrls[i]->m_pReflect) - m_aUnitMtrls[i]->m_pReflect->onLostDevice(); - } -} - -void CMaterials::onResetDevice() -{ - for (int i = 0; i < m_aUnitMtrls.size(); ++i) - { - if (m_aUnitMtrls[i] && m_aUnitMtrls[i]->m_pReflect) - m_aUnitMtrls[i]->m_pReflect->onResetDevice(); - } -} - -//########################################################################## - -ID CMaterials::getStdMtl(MTLTYPE_MODEL type_model) -{ - if (type_model == MTLTYPE_MODEL_STATIC) - { - return MtrlDefStatic; - } - else if (type_model == MTLTYPE_MODEL_GRASS) - { - return MtrlDefGrass; - } - else if (type_model == MTLTYPE_MODEL_TREE) - { - return MtrlDefTree; - } - else if (type_model == MTLTYPE_MODEL_SKIN) - { - return MtrlDefSkin; - } - return(-1); -} - -MTLTYPE_MODEL CMaterials::getTypeModel(ID id) -{ - MTL_PRE_COND_ID(id, MTLTYPE_MODEL_STATIC); - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.type_model; -} - -void CMaterials::setTypeModel(ID id, MTLTYPE_MODEL type_model) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.type_model = type_model; -} - -void CMaterials::update(UINT timeDelta) -{ - m_uiCurrTimeDelta = timeDelta; - m_uiCountTimeDelta += timeDelta; -} - -void CMaterials::setMainTexture(ID slot, ID id) -{ - if (id >= 0 && id < m_aUnitMtrls.size() && m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idMainTexture != -1) - MLSet::DXDevice->SetTexture(slot, SGCore_LoadTexGetTex(m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idMainTexture)); - else - MLSet::DXDevice->SetTexture(slot, 0); -} - -ID CMaterials::getID(const char* name) -{ - for (int i = 0; i < m_aUnitMtrls.size(); i++) - { - if (strcmp(m_aUnitMtrls[i]->m_pMtrl->m_sName.c_str(), name) == 0) - return i; - } - return -1; -} - -int CMaterials::getCount() -{ - return m_aUnitMtrls.size(); -} - - -void CMaterials::setForceblyAlphaTest(bool isat) -{ - m_useForceblyAlphaTest = isat; - if (!isat) - MLSet::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); -} - -bool CMaterials::getForceblyAlphaTest() -{ - return m_useForceblyAlphaTest; -} - -//########################################################################## - -bool CMaterials::mtlGetUsingAlphaTest(ID id) -{ - MTL_PRE_COND_ID(id, false); - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_useAlphaTest; -} - -void CMaterials::mtlSetUsingAlphaTest(ID id, bool is_using) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_useAlphaTest = is_using; -} - -MTLTYPE_REFLECT CMaterials::mtlTypeReflection(ID id) -{ - MTL_PRE_COND_ID(id, MTLTYPE_REFLECT_NONE); - return m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_type_reflect; -} - -//************************************************************************** - -void CMaterials::mtlRefSetIDArr(ID id, ID inid, int cube, ID idarr) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->setIDArr(inid, cube, idarr); -} - -ID CMaterials::mtlRefGetIDArr(ID id, ID inid, int cube) -{ - MTL_REF_PRE_COND_ID(id,- 1); - return m_aUnitMtrls[id]->m_pReflect->getIDArr(inid, cube); -} - -/*void CMaterials::mtlRefSetPlane(ID id, D3DXPLANE* plane) -{ - MTL_REF_PRE_COND_ID(id); - m_aUnitMtrls[id]->m_pReflect->Plane = *plane; -}*/ - -/*void CMaterials::mtlRefSetCenter(ID id, float3_t* center) -{ - MTL_REF_PRE_COND_ID(id); - m_aUnitMtrls[id]->m_pReflect->Position = *center; -}*/ - -void CMaterials::mtlRefPreRenderPlane(ID id, D3DXPLANE* plane) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->preRenderRefPlane(plane); -} - -const IFrustum* CMaterials::mtlRefGetfrustum(ID id, int cube) -{ - MTL_REF_PRE_COND_ID(id, 0); - if (cube == 0 || (cube > 0 && (m_aUnitMtrls[id]->m_pReflect->getTypeReflect() == MTLTYPE_REFLECT_CUBE_STATIC || m_aUnitMtrls[id]->m_pReflect->getTypeReflect() == MTLTYPE_REFLECT_CUBE_DYNAMIC))) - return m_aUnitMtrls[id]->m_pReflect->getFrustum(cube); - return 0; -} - -void CMaterials::mtlRefPostRenderPlane(ID id) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->postRenderRefPlane(); -} - -IDirect3DTexture9* CMaterials::mtlRefPlaneGetTex(ID id) -{ - MTL_REF_PRE_COND_ID(id, 0); - return m_aUnitMtrls[id]->m_pReflect->getRefPlaneTex(); -} - - -void CMaterials::mtlRefSetMinMax(ID id, const float3_t *pMin, const float3_t *pMax) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->setMinMax(pMin, pMax); -} - -bool CMaterials::mtlRefIsAllowedRender(ID id) -{ - MTL_REF_PRE_COND_ID(id, false); - if (m_aUnitMtrls[id]->m_pReflect) - return m_aUnitMtrls[id]->m_pReflect->allowedRender(); - - return false; -} - - -void CMaterials::mtlRefCubeBeginRender(ID id, const float3_t *pCenter) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->beginRenderRefCube(pCenter); -} - -void CMaterials::mtlRefCubePreRender(ID id, int iCube, const float4x4 *pWorld) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->preRenderRefCube(iCube, pWorld); -} - -void CMaterials::mtlRefCubePostRender(ID id, int iCube) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->postRenderRefCube(iCube); -} - -void CMaterials::mtlRefCubeEndRender(ID id, const float3_t *pViewPos) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->endRenderRefCube(pViewPos); -} - -bool CMaterials::mtlRefUpdateCountUpdate(ID id, const float3_t *pViewPos) -{ - MTL_REF_PRE_COND_ID(id, false); - return m_aUnitMtrls[id]->m_pReflect->updateCountUpdate(pViewPos); -} - -void CMaterials::mtlRefNullingCountUpdate(ID id) -{ - MTL_REF_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pReflect->nullingCountUpdate(); -} - -IDirect3DCubeTexture9* CMaterials::refCubeGetTex(ID id) -{ - MTL_REF_PRE_COND_ID(id, 0); - return m_aUnitMtrls[id]->m_pReflect->getRefCubeTex(); -} - -//************************************************************************** - -void CMaterials::mtlSetPhysicMaterial(ID id, MTLTYPE_PHYSIC type) -{ - MTL_PRE_COND_ID(id); - m_aUnitMtrls[id]->m_pMtrl->m_oPhysics.type_physics = type; -} - -MTLTYPE_PHYSIC CMaterials::mtlGetPhysicMaterial(ID id) -{ - MTL_PRE_COND_ID(id, MTLTYPE_PHYSIC_CONCRETE); - return m_aUnitMtrls[id]->m_pMtrl->m_oPhysics.type_physics; -} - -void CMaterials::mtlSetTexture(ID id, const char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idMainTexture = SGCore_LoadTexAddName(path_tex, LOAD_TEXTURE_TYPE_LOAD); -} - -void CMaterials::mtlGetTexture(ID id, char* name) -{ - MTL_PRE_COND_ID(id, _VOID); - - if (name && m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idMainTexture >= 0) - SGCore_LoadTexGetName(m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idMainTexture, name); -} - -ID CMaterials::mtlGetTextureID(ID id) -{ - MTL_PRE_COND_ID(id, -1); - - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idMainTexture; -} - -void CMaterials::mtlSetVS(ID id, const char* path_vs) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idShaderVS = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, path_vs, path_vs, SHADER_CHECKDOUBLE_PATH); -} - -void CMaterials::mtlGetVS(ID id, char* name) -{ - MTL_PRE_COND_ID(id, _VOID); - SGCore_ShaderGetPath(SHADER_TYPE_VERTEX, m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idShaderVS, name); -} - -void CMaterials::mtlSetPS(ID id, const char* path_ps) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idShaderPS = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, path_ps, path_ps, SHADER_CHECKDOUBLE_PATH); -} - -void CMaterials::mtlGetPS(ID id, char* name) -{ - MTL_PRE_COND_ID(id, _VOID); - SGCore_ShaderGetPath(SHADER_TYPE_PIXEL, m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_idShaderPS, name); -} - - -void CMaterials::mtlSetLighting(ID id, bool is_lighting) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_isUnlit = !is_lighting; -} - -bool CMaterials::mtlGetLighting(ID id) -{ - MTL_PRE_COND_ID(id, false); - return !m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_isUnlit; -} - - -void CMaterials::mtlSetIsTextureLighting(ID id, bool is_tex_lighting) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_isTextureParam = is_tex_lighting; -} - -bool CMaterials::mtlGetIsTextureLighting(ID id) -{ - MTL_PRE_COND_ID(id, false); - return m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_isTextureParam; -} - - -void CMaterials::mtlSetTextureLighting(ID id, const char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_idTexParam = SGCore_LoadTexAddName(path_tex, LOAD_TEXTURE_TYPE_LOAD); -} - -void CMaterials::mtlGetTextureLighting(ID id, char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - if (path_tex && m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_idTexParam >= 0) - { - SGCore_LoadTexGetName(m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_idTexParam, path_tex); - if (path_tex[0] == MTL_VIRTUAL_DIR_HAND_MTL) - path_tex[0] = 0; - } - else if (path_tex) - path_tex[0] = 0; -} - - -void CMaterials::mtlSetRoughness(ID id, float roughness) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_fRoughness = roughness; -} - -float CMaterials::mtlGetRoughness(ID id) -{ - MTL_PRE_COND_ID(id, -1); - return m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_fRoughness; -} - - -void CMaterials::mtlSetF0(ID id, float f0) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_fF0 = f0; -} - -float CMaterials::mtlGetF0(ID id) -{ - MTL_PRE_COND_ID(id, -1); - return m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_fF0; -} - - -void CMaterials::mtlSetThickness(ID id, float thickness) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_fThickness = thickness; -} - -float CMaterials::mtlGetThickness(ID id) -{ - MTL_PRE_COND_ID(id, -1); - return m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_fThickness; -} - - -void CMaterials::mtlSetDurability(ID id, float fDurability) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oPhysics.m_fDurability = fDurability; -} - -float CMaterials::mtlGetDurability(ID id) -{ - MTL_PRE_COND_ID(id, -1); - return m_aUnitMtrls[id]->m_pMtrl->m_oPhysics.m_fDurability; -} - - -void CMaterials::mtlSetHitChance(ID id, float fHitChance) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oPhysics.m_fHitChance = fHitChance; -} - -float CMaterials::mtlGetHitChance(ID id) -{ - MTL_PRE_COND_ID(id, -1); - return m_aUnitMtrls[id]->m_pMtrl->m_oPhysics.m_fHitChance; -} - - -void CMaterials::mtlSetDensity(ID id, float fDensity) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oPhysics.m_fDensity = fDensity; -} - -float CMaterials::mtlGetDensity(ID id) -{ - MTL_PRE_COND_ID(id, -1); - return m_aUnitMtrls[id]->m_pMtrl->m_oPhysics.m_fDensity; -} - - - -void CMaterials::mtlSetTypeTransparency(ID id, MTLTYPE_TRANSPARENCY type) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_type_transparency = type; -} - -MTLTYPE_TRANSPARENCY CMaterials::mtlGetTypeTransparency(ID id) -{ - MTL_PRE_COND_ID(id, MTLTYPE_TRANSPARENCY_NONE); - return m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_type_transparency; -} - - -void CMaterials::mtlSetTypeReflection(ID id, MTLTYPE_REFLECT type) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_type_reflect = type; - - if (m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_type_reflect != MTLTYPE_REFLECT_NONE) - { - if (!m_aUnitMtrls[id]->m_pReflect) - m_aUnitMtrls[id]->m_pReflect = new CReflection(); - - m_aUnitMtrls[id]->m_pReflect->init(m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_type_reflect); - } -} - -MTLTYPE_REFLECT CMaterials::mtlGetTypeReflection(ID id) -{ - MTL_PRE_COND_ID(id, MTLTYPE_REFLECT_NONE); - return m_aUnitMtrls[id]->m_pMtrl->m_oLightParam.m_type_reflect; -} - - -void CMaterials::mtlSetMaskTex(ID id, const char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_idMask = SGCore_LoadTexAddName(path_tex, LOAD_TEXTURE_TYPE_LOAD); -} - -void CMaterials::mtlGetMaskTex(ID id, char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - if (path_tex && m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_idMask >= 0) - SGCore_LoadTexGetName(m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_idMask, path_tex); - else if (path_tex) - path_tex[0] = 0; -} - -void CMaterials::mtlSetMRTex(ID id, int channel, const char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_aMicroRelief[channel] = SGCore_LoadTexAddName(path_tex, LOAD_TEXTURE_TYPE_LOAD); -} - -void CMaterials::mtlGetMRTex(ID id, int channel, char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - if (path_tex && m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_aMicroRelief[channel] >= 0) - SGCore_LoadTexGetName(m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_aMicroRelief[channel], path_tex); - else if (path_tex) - path_tex[0] = 0; -} - - -void CMaterials::mtlSetDTex(ID id, int channel, const char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_aDetail[channel] = SGCore_LoadTexAddName(path_tex, LOAD_TEXTURE_TYPE_LOAD); -} - -void CMaterials::mtlGetDTex(ID id, int channel, char* path_tex) -{ - MTL_PRE_COND_ID(id, _VOID); - if (path_tex && m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_aDetail[channel] >= 0) - SGCore_LoadTexGetName(m_aUnitMtrls[id]->m_pMtrl->m_oMicroDetail.m_aDetail[channel], path_tex); - else if (path_tex) - path_tex[0] = 0; -} - - -void CMaterials::mtlSetStdVS(ID id, MTL_SHADERSTD type, bool is_send) -{ - MTL_PRE_COND_ID(id, _VOID); - if (type == MTL_SHADERSTD_MATRIX_WORLD) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorld = is_send; - else if (type == MTL_SHADERSTD_MATRIX_VIEW) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransView = is_send; - else if (type == MTL_SHADERSTD_MATRIX_PROJECTION) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransProjection = is_send; - else if (type == MTL_SHADERSTD_MATRIX_WORLDVIEW) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldView = is_send; - else if (type == MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection = is_send; - - else if (type == MTL_SHADERSTD_CAMPOS) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransPosCam = is_send; - else if (type == MTL_SHADERSTD_TIMEDELTA) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransTimeDelta = is_send; - - else if (type == MTL_SHADERSTD_USERDATA) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransUserData = is_send; - - else if (type == MTL_SHADERSTD_WINSIZE) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWinSize = is_send; -} - -bool CMaterials::mtlGetStdVS(ID id, MTL_SHADERSTD type) -{ - MTL_PRE_COND_ID(id, false); - if (type == MTL_SHADERSTD_MATRIX_WORLD) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorld; - else if (type == MTL_SHADERSTD_MATRIX_VIEW) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransView; - else if (type == MTL_SHADERSTD_MATRIX_PROJECTION) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransProjection; - else if (type == MTL_SHADERSTD_MATRIX_WORLDVIEW) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldView; - else if (type == MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection; - - else if (type == MTL_SHADERSTD_CAMPOS) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransPosCam; - else if (type == MTL_SHADERSTD_TIMEDELTA) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransTimeDelta; - - else if (type == MTL_SHADERSTD_USERDATA) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransUserData; - - else if (type == MTL_SHADERSTD_WINSIZE) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWinSize; - - return(false); -} - -void CMaterials::mtlSetStdPS(ID id, MTL_SHADERSTD type, bool is_send) -{ - MTL_PRE_COND_ID(id, _VOID); - if (type == MTL_SHADERSTD_MATRIX_WORLD) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorld = is_send; - else if (type == MTL_SHADERSTD_MATRIX_VIEW) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransView = is_send; - else if (type == MTL_SHADERSTD_MATRIX_PROJECTION) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransProjection = is_send; - else if (type == MTL_SHADERSTD_MATRIX_WORLDVIEW) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldView = is_send; - else if (type == MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection = is_send; - - else if (type == MTL_SHADERSTD_CAMPOS) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransPosCam = is_send; - else if (type == MTL_SHADERSTD_TIMEDELTA) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransTimeDelta = is_send; - - else if (type == MTL_SHADERSTD_USERDATA) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransUserData = is_send; - - else if (type == MTL_SHADERSTD_WINSIZE) - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWinSize = is_send; -} - -bool CMaterials::mtlGetStdPS(ID id, MTL_SHADERSTD type) -{ - MTL_PRE_COND_ID(id, false); - if (type == MTL_SHADERSTD_MATRIX_WORLD) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorld; - else if (type == MTL_SHADERSTD_MATRIX_VIEW) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransView; - else if (type == MTL_SHADERSTD_MATRIX_PROJECTION) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransProjection; - else if (type == MTL_SHADERSTD_MATRIX_WORLDVIEW) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldView; - else if (type == MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection; - - else if (type == MTL_SHADERSTD_CAMPOS) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransPosCam; - else if (type == MTL_SHADERSTD_TIMEDELTA) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransTimeDelta; - - else if (type == MTL_SHADERSTD_USERDATA) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransUserData; - - else if (type == MTL_SHADERSTD_WINSIZE) - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWinSize; - return(false); -} - - -void CMaterials::mtlSetUserDataVS(ID id, int component, float val) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_vUserData[component] = val; -} - -float CMaterials::mtlGetUserDataVS(ID id, int component) -{ - MTL_PRE_COND_ID(id, -1); - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_vUserData[component]; -} - -void CMaterials::mtlSetUserDataVS_InPS(ID id, bool is_send_ps) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransUserDataInOtherShader = is_send_ps; -} - -bool CMaterials::mtlGetUserDataVS_InPS(ID id) -{ - MTL_PRE_COND_ID(id, false); - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataVS.m_isTransUserDataInOtherShader; -} - - -void CMaterials::mtlSetUserDataPS(ID id, int component, float val) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_vUserData[component] = val; -} - -float CMaterials::mtlGetUserDataPS(ID id, int component) -{ - MTL_PRE_COND_ID(id, -1); - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_vUserData[component]; -} - -void CMaterials::mtlSetUserDataPS_InPS(ID id, bool is_send_vs) -{ - MTL_PRE_COND_ID(id, _VOID); - m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransUserDataInOtherShader = is_send_vs; -} - -bool CMaterials::mtlGetUserDataPS_InPS(ID id) -{ - MTL_PRE_COND_ID(id, false); - return m_aUnitMtrls[id]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_isTransUserDataInOtherShader; -} - -//########################################################################## - -void CMaterials::setIsIncrCountSurf(bool bf) -{ - m_useCountSurface = bf; -} - -bool CMaterials::getIsIncrCountSurf() -{ - return m_useCountSurface; -} - -void CMaterials::nullingCurrCountSurf() -{ - m_idCurrIdSurface = 0; -} - -int CMaterials::getCurrCountSurf() -{ - return m_idCurrIdSurface; -} - -void CMaterials::setCurrCountSurf(int count) -{ - m_idCurrIdSurface = count; -} - -//########################################################################## - -void CMaterials::renderStd(MTLTYPE_MODEL type, const float4x4 *pWorld, ID idSlot, ID idMtl) -{ - //может быть случай когда текстура в которую сейчас рисуем еще стоит в текстурных слотах - //из-за этого может быть необъяснимое поводенеие и как результат непонятные артефакты в самой текстуре в которую сейчас рисуем - //поэтому нужно обнулить слот в котором возможно была текстура - //такое явление может быть в случае когда в кадре только один материал который отражает - MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, 0); - - if (idMtl >= 0 && idMtl < m_aUnitMtrls.size()) - setMainTexture(idSlot, idMtl); - - if (type == MTLTYPE_MODEL_STATIC) - { - SGCore_ShaderBind(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::StdGeom); - - float4x4 wmat = (pWorld ? (*pWorld) : SMMatrixIdentity()); - float4x4 wvpmat; - Core_RMatrixGet(G_RI_MATRIX_VIEWPROJ, &wvpmat); - wvpmat = SMMatrixTranspose(wmat * wvpmat); - wmat = SMMatrixTranspose(wmat); - - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::StdGeom, "WorldViewProjection", &wvpmat); - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::StdGeom, "World", &wmat); - - if (Core_RBoolGet(G_RI_BOOL_CLIPPLANE0)) - { - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdGeomCP); - - float3 tmpnormal, tmppoint; - - Core_RFloat3Get(G_RI_FLOAT3_CLIPPLANE0_NORMAL, &tmpnormal); - Core_RFloat3Get(G_RI_FLOAT3_CLIPPLANE0_POINT, &tmppoint); - - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdGeomCP, "PlaneNormal", &tmpnormal); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdGeomCP, "PlanePoint", &tmppoint); - } - else - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdGeom); - } - else if (type == MTLTYPE_MODEL_GRASS || type == MTLTYPE_MODEL_TREE) - { - ID tmpvs = (type == MTLTYPE_MODEL_GRASS ? MLSet::IDsShaders::VS::StdGrass : MLSet::IDsShaders::VS::StdTree); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, tmpvs); - - float4x4 wmat = (pWorld ? (*pWorld) : SMMatrixIdentity()); - float4x4 wvpmat; - Core_RMatrixGet(G_RI_MATRIX_VIEWPROJ, &wvpmat); - wvpmat = SMMatrixTranspose(wmat * wvpmat); - wmat = SMMatrixTranspose(wmat); - - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, tmpvs, "WorldViewProjection", &wvpmat); - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, tmpvs, "World", &wmat); - - if (Core_RBoolGet(G_RI_BOOL_CLIPPLANE0)) - { - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdGreenCP); - - float3 tmpnormal, tmppoint; - - Core_RFloat3Get(G_RI_FLOAT3_CLIPPLANE0_NORMAL, &tmpnormal); - Core_RFloat3Get(G_RI_FLOAT3_CLIPPLANE0_POINT, &tmppoint); - - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdGreenCP, "PlaneNormal", &tmpnormal); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdGreenCP, "PlanePoint", &tmppoint); - } - else - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdGreen); - } - else if (type == MTLTYPE_MODEL_SKIN) - { - SGCore_ShaderBind(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::StdSkin); - - float4x4 wmat = (pWorld ? (*pWorld) : SMMatrixIdentity()); - float4x4 wvpmat; - Core_RMatrixGet(G_RI_MATRIX_VIEWPROJ, &wvpmat); - wvpmat = SMMatrixTranspose(wmat * wvpmat); - wmat = SMMatrixTranspose(wmat); - - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::StdSkin, "WorldViewProjection", &wvpmat); - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, MLSet::IDsShaders::VS::StdSkin, "World", &wmat); - - if (Core_RBoolGet(G_RI_BOOL_CLIPPLANE0)) - { - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdSkinCP); - - float3 tmpnormal, tmppoint; - - Core_RFloat3Get(G_RI_FLOAT3_CLIPPLANE0_NORMAL, &tmpnormal); - Core_RFloat3Get(G_RI_FLOAT3_CLIPPLANE0_POINT, &tmppoint); - - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdSkinCP, "PlaneNormal", &tmpnormal); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdSkinCP, "PlanePoint", &tmppoint); - } - else - SGCore_ShaderBind(SHADER_TYPE_PIXEL, MLSet::IDsShaders::PS::StdSkin); - } -} - -void CMaterials::render(ID id, const float4x4 *pWorld) -{ - MTL_PRE_COND_ID(id, _VOID); - - static const int *r_win_width = GET_PCVAR_INT("r_win_width"); - static const int *r_win_height = GET_PCVAR_INT("r_win_height"); - - static const float *r_near = GET_PCVAR_FLOAT("r_near"); - static const float *r_far = GET_PCVAR_FLOAT("r_far"); - - m_mWorld = (pWorld ? (*pWorld) : SMMatrixIdentity()); - - CMaterial *pMtrl = m_aUnitMtrls[id]->m_pMtrl; - - //если есть то устанавливаем текстуру материала - if (pMtrl->m_oMainGraphics.m_idMainTexture != -1) - MLSet::DXDevice->SetTexture(MTL_TEX_R_MAIN, SGCore_LoadTexGetTex(pMtrl->m_oMainGraphics.m_idMainTexture)); - - //если нет отражени¤ то отправл¤ем 0 - if (pMtrl->m_oLightParam.m_type_reflect == 0) - MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, 0); - else - { - if (m_aUnitMtrls[id]->m_pReflect->getTypeReflect() == MTLTYPE_REFLECT_PLANE) - MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, m_aUnitMtrls[id]->m_pReflect->getRefPlaneTex()); - else if (m_aUnitMtrls[id]->m_pReflect->getTypeReflect() == MTLTYPE_REFLECT_CUBE_STATIC || m_aUnitMtrls[id]->m_pReflect->getTypeReflect() == MTLTYPE_REFLECT_CUBE_DYNAMIC) - MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, m_aUnitMtrls[id]->m_pReflect->getRefCubeTex()); - } - - MLSet::DXDevice->SetTexture(MTL_TEX_R_CURR_DEPTH, SGCore_RTGetTexture(MLSet::IDsRenderTargets::DepthScene0)); - - //если есть рефаркци¤, а она идет вторым проходом, то отправл¤ем, иначе посылаем 0 - /*if (pMtrl->m_oLightParam.m_type_transparency) - MLSet::DXDevice->SetTexture(MTL_TEX_R_REFRACTION, SGCore_RTGetTexture(SML_DSGetRT_ID(DS_RT_SCENE_LIGHT_COM_REF))); - else - MLSet::DXDevice->SetTexture(MTL_TEX_R_REFRACTION, 0);*/ - - if (pMtrl->m_oMicroDetail.m_idMask != -1) - MLSet::DXDevice->SetTexture(MTL_TEX_R_MASK, SGCore_LoadTexGetTex(pMtrl->m_oMicroDetail.m_idMask)); - - for (int k = 0; k<4; k++) - { - if (pMtrl->m_oMicroDetail.m_aDetail[k] != -1) - MLSet::DXDevice->SetTexture(MTL_TEX_R_DETAIL + k, SGCore_LoadTexGetTex(pMtrl->m_oMicroDetail.m_aDetail[k])); - else - MLSet::DXDevice->SetTexture(MTL_TEX_R_DETAIL + k, 0); - - if (pMtrl->m_oMicroDetail.m_aMicroRelief[k] != -1) - MLSet::DXDevice->SetTexture(MTL_TEX_R_MICRO + k, SGCore_LoadTexGetTex(pMtrl->m_oMicroDetail.m_aMicroRelief[k])); - else - MLSet::DXDevice->SetTexture(MTL_TEX_R_MICRO + k, 0); - } - - //если есть текстура с параметрами освещени¤ и установлено что берем параметры из текстуры, то отправл¤ем текстуру с параметрами - if (pMtrl->m_oLightParam.m_idTexParam != -1 && pMtrl->m_oLightParam.m_isTextureParam) - { - MLSet::DXDevice->SetTexture(MTL_TEX_R_PARAM_LIGHT, SGCore_LoadTexGetTex(pMtrl->m_oLightParam.m_idTexParam)); - } - //иначе если берем параметры из ... редактора - else if (!pMtrl->m_oLightParam.m_isTextureParam) - { - if (pMtrl->m_oLightParam.m_fOldRoughness != pMtrl->m_oLightParam.m_fRoughness || pMtrl->m_oLightParam.m_fOldF0 != pMtrl->m_oLightParam.m_fF0 || pMtrl->m_oLightParam.m_fOldThickness != pMtrl->m_oLightParam.m_fThickness) - { - //блокируем текстуру 1х1 котора¤ есть параметры освещени¤, и запсиываем туда то что настроили - D3DLOCKED_RECT LockedRect; - IDirect3DTexture9* ParamLightModelTex = SGCore_LoadTexGetTex(pMtrl->m_oLightParam.m_idTexParamHand); - ParamLightModelTex->LockRect(0, &LockedRect, 0, 0); - DWORD *param = (DWORD*)LockedRect.pBits; - //DWORD param = D3DCOLOR_ARGB(0,0,0,0); - param[0] = D3DCOLOR_ARGB(0, DWORD(pMtrl->m_oLightParam.m_fRoughness*255.f), DWORD(pMtrl->m_oLightParam.m_fF0*255.f), DWORD(pMtrl->m_oLightParam.m_fThickness*255.f)); - ParamLightModelTex->UnlockRect(0); - - pMtrl->m_oLightParam.m_fOldRoughness = pMtrl->m_oLightParam.m_fRoughness; - pMtrl->m_oLightParam.m_fOldF0 = pMtrl->m_oLightParam.m_fF0; - pMtrl->m_oLightParam.m_fOldThickness = pMtrl->m_oLightParam.m_fThickness; - } - - MLSet::DXDevice->SetTexture(MTL_TEX_R_PARAM_LIGHT, SGCore_LoadTexGetTex(pMtrl->m_oLightParam.m_idTexParamHand)); - } - else - MLSet::DXDevice->SetTexture(MTL_TEX_R_PARAM_LIGHT, SGCore_LoadTexGetTex(MLSet::IDsTexs::NullMaterial)); - - - if (pMtrl->m_oMainGraphics.m_idShaderVS != -1) - SGCore_ShaderBind(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS); - - if (pMtrl->m_oMainGraphics.m_idShaderPS != -1) - SGCore_ShaderBind(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorld || pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorld || pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldView || pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldView || pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection || pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection) - m_mWorldTrans = SMMatrixTranspose(m_mWorld); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldView || pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldView || pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection || pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection) - { - //float4x4 view; - Core_RMatrixGet(G_RI_MATRIX_VIEW, &m_mViewTrans); - //MLSet::DXDevice->GetTransform(D3DTS_VIEW, &tmpView); - //view = float4x4(tmpView); - m_mViewTrans = SMMatrixTranspose(m_mViewTrans); - - //float4x4 proj; - Core_RMatrixGet(G_RI_MATRIX_PROJECTION, &m_mProjTrans); - //MLSet::DXDevice->GetTransform(D3DTS_PROJECTION, &tmpProjection); - //proj = float4x4(tmpProjection); - m_mProjTrans = SMMatrixTranspose(m_mProjTrans); - } - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorld) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "World", &m_mWorldTrans); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorld) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "World", &m_mWorldTrans); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransView) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "View", &m_mViewTrans); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransView) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "View", &m_mViewTrans); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransProjection) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "Projection", &m_mProjTrans); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransProjection) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "Projection", &m_mProjTrans); - - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldView || pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldView) - { - float4x4 wv = m_mViewTrans * m_mWorldTrans; - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldView) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "WorldView", &wv); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldView) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "WorldView", &wv); - } - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection || pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection) - { - Core_RMatrixGet(G_RI_MATRIX_VIEWPROJ, &m_mViewProj); - - float4x4 mWVP = m_mWorld * m_mViewProj; - mWVP = SMMatrixTranspose(mWVP); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWorldViewProjection) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "WorldViewProjection", &mWVP); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWorldViewProjection) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "WorldViewProjection", &mWVP); - } - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransPosCam || pMtrl->m_oMainGraphics.m_oDataPS.m_isTransPosCam) - { - float3 vObserverPos; - Core_RFloat3Get(G_RI_FLOAT3_OBSERVER_POSITION, &vObserverPos); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransPosCam) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "PosCam", &vObserverPos); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransPosCam) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "PosCam", &vObserverPos); - } - - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransUserData) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "Param", &(pMtrl->m_oMainGraphics.m_oDataVS.m_vUserData)); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransUserDataInOtherShader) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "ParamVS", &(pMtrl->m_oMainGraphics.m_oDataVS.m_vUserData)); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransUserData) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "Param", &(pMtrl->m_oMainGraphics.m_oDataPS.m_vUserData)); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransUserDataInOtherShader) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "ParamPS", &(pMtrl->m_oMainGraphics.m_oDataPS.m_vUserData)); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransTimeDelta) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "TimeDelta", &float2(m_uiCountTimeDelta, float(m_uiCurrTimeDelta) * 0.001f)); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransTimeDelta) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "TimeDelta", &float2(m_uiCountTimeDelta, float(m_uiCurrTimeDelta) * 0.001f)); - - if (pMtrl->m_oMainGraphics.m_oDataVS.m_isTransWinSize) - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, pMtrl->m_oMainGraphics.m_idShaderVS, "WinSize", &float2_t(*r_win_width, *r_win_height)); - - if (pMtrl->m_oMainGraphics.m_oDataPS.m_isTransWinSize) - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "WinSize", &float2_t(*r_win_width, *r_win_height)); - - //если материалом назначен альфа тест и не включен принудительный - if (pMtrl->m_oMainGraphics.m_useAlphaTest && !m_useForceblyAlphaTest) - { - MLSet::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE); - MLSet::DXDevice->SetRenderState(D3DRS_ALPHAREF, MTL_ALPHATEST_FREE_VALUE); - MLSet::DXDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL); - } - //если не включен принудительный альфа тест - else if (!m_useForceblyAlphaTest) - { - MLSet::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - } - //иначе включен принудительный альфа тест - else - { - MLSet::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE); - MLSet::DXDevice->SetRenderState(D3DRS_ALPHAREF, MTL_ALPHATEST_FORCEBLY_VALUE); - MLSet::DXDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL); - } - - //почти во всех пиксельных шейдерах материалов есть данна¤ NearFar, необходима¤ д¤л записи глубины - if (pMtrl->m_oMainGraphics.m_idShaderPS != -1) - { - //освещаемый ли тип материала или нет? Ппрозрачный освещаемый? - //0,0.33,0.66,1 - float fLayer; - if (pMtrl->m_oMainGraphics.m_isUnlit) - { - if (pMtrl->m_oLightParam.m_type_transparency == MTLTYPE_TRANSPARENCY_NONE) - fLayer = MTLTYPE_LAYER_OPAQUE_UNLIT; - else - fLayer = MTLTYPE_LAYER_TRANSPARENT_UNLIT; - } - else - { - if (pMtrl->m_oLightParam.m_type_transparency == MTLTYPE_TRANSPARENCY_NONE) - fLayer = MTLTYPE_LAYER_OPAQUE_LIGHT; - else - fLayer = MTLTYPE_LAYER_TRANSPARENT_LIGHT; - } - - if (m_useCountSurface && (pMtrl->m_oLightParam.m_type_transparency == MTLTYPE_TRANSPARENCY_ALPHA_LIGHT || pMtrl->m_oLightParam.m_type_transparency == MTLTYPE_TRANSPARENCY_ALPHA_UNLIT)) - ++(m_idCurrIdSurface); - - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, pMtrl->m_oMainGraphics.m_idShaderPS, "NearFarIsUnlit", &float4_t(*r_near, *r_far, fLayer, float(m_idCurrIdSurface) / 255.f)); - } -} - -void CMaterials::renderLight(const float4_t *pColor, const float4x4 *pWorld) -{ - MTL_PRE_COND_ID(MtrlDefLight, _VOID); - - m_aUnitMtrls[MtrlDefLight]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_vUserData = *pColor; - render(MtrlDefLight, pWorld); - m_aUnitMtrls[MtrlDefLight]->m_pMtrl->m_oMainGraphics.m_oDataPS.m_vUserData = float4(0, 0, 0, 0); -} \ No newline at end of file diff --git "a/source/mtllight/material - \320\272\320\276\320\277\320\270\321\217.h" "b/source/mtllight/material - \320\272\320\276\320\277\320\270\321\217.h" deleted file mode 100644 index 097f3ea2dfa881db14c2569d698c8adc9f0e1981..0000000000000000000000000000000000000000 --- "a/source/mtllight/material - \320\272\320\276\320\277\320\270\321\217.h" +++ /dev/null @@ -1,431 +0,0 @@ - -/*********************************************************** -Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 -See the license in LICENSE -***********************************************************/ - -#ifndef __MATERIAL_H -#define __MATERIAL_H - -#include -#include -#include -#include "reflection.h" -#include - -#define MTL_PRE_COND_ID(id,stdval) \ -if (!(id >= 0 && id < m_aUnitMtrls.size()))\ -{LibReport(REPORT_MSG_LEVEL_ERROR, "%s - material: unresolved index of access '%d'", GEN_MSG_LOCATION, id); return stdval; }\ -else if (!m_aUnitMtrls[id])\ -{LibReport(REPORT_MSG_LEVEL_ERROR, "%s - material: material '%d' is not init", GEN_MSG_LOCATION, id); return stdval; } - -#define MTL_REF_PRE_COND_ID(id,stdval) \ -MTL_PRE_COND_ID(id, stdval)\ -if (!(m_aUnitMtrls[id]->m_pReflect))\ -{LibReport(REPORT_MSG_LEVEL_ERROR, "%s - material: material id = '%d', name = '%s' unsupported reflection", GEN_MSG_LOCATION, id, m_aUnitMtrls[id]->m_pMtrl->m_sName.c_str()); return stdval; } - -class CMaterials -{ -public: - CMaterials(); - ~CMaterials(); - - void onLostDevice(); - void onResetDevice(); - - SX_ALIGNED_OP_MEM - - void clear(bool isClearRefDel); - void update(UINT timeDelta); - void setMainTexture(ID idSlot, ID idTexure); - void render(ID id, const float4x4 *pWorld); - void renderStd(MTLTYPE_MODEL type, const float4x4 *pWorld, ID idSlot, ID idMtl); - void renderLight(const float4_t *pColor, const float4x4 *pWorld); - int getCount(); - - void setForceblyAlphaTest(bool useAlphaTest); - bool getForceblyAlphaTest(); - - void setIsIncrCountSurf(bool bf); - bool getIsIncrCountSurf(); - void nullingCurrCountSurf(); - int getCurrCountSurf(); - void setCurrCountSurf(int iCount); - - ID mtlLoad(const char *szName, MTLTYPE_MODEL type = MTLTYPE_MODEL_STATIC); - void mtlReLoad(ID id, const char *szName = 0); - void mtlSave(ID id); - - ID getStdMtl(MTLTYPE_MODEL type_model); - ID exists(const char *szName); - MTLTYPE_MODEL getTypeModel(ID id); - void setTypeModel(ID id, MTLTYPE_MODEL type_model); - ID getID(const char *szName); - - //###################################################################### - - bool mtlGetUsingAlphaTest(ID id); - void mtlSetUsingAlphaTest(ID id, bool isUsing); - MTLTYPE_REFLECT mtlTypeReflection(ID id); - - void mtlSetPhysicMaterial(ID id, MTLTYPE_PHYSIC type); - MTLTYPE_PHYSIC mtlGetPhysicMaterial(ID id); - - void mtlSetTexture(ID id, const char *szTexture); - void mtlGetTexture(ID id, char *szName); - ID mtlGetTextureID(ID id); - void mtlSetVS(ID id, const char *szNameVS); - void mtlGetVS(ID id, char *szNamePS); - void mtlSetPS(ID id, const char *szNamePS); - void mtlGetPS(ID id, char *szNamePS); - - - void mtlSetLighting(ID id, bool isLighting); - bool mtlGetLighting(ID id); - - void mtlSetIsTextureLighting(ID id, bool isTexLighting); - bool mtlGetIsTextureLighting(ID id); - - void mtlSetTextureLighting(ID id, const char *szTex); - void mtlGetTextureLighting(ID id, char *szTex); - - void mtlSetRoughness(ID id, float fRroughness); - float mtlGetRoughness(ID id); - - void mtlSetF0(ID id, float fF0); - float mtlGetF0(ID id); - - void mtlSetThickness(ID id, float fThickness); - float mtlGetThickness(ID id); - - void mtlSetDurability(ID id, float fDurability); - float mtlGetDurability(ID id); - - void mtlSetHitChance(ID id, float fHitChance); - float mtlGetHitChance(ID id); - - void mtlSetDensity(ID id, float fDensity); - float mtlGetDensity(ID id); - - void mtlSetTypeTransparency(ID id, MTLTYPE_TRANSPARENCY type); - MTLTYPE_TRANSPARENCY mtlGetTypeTransparency(ID id); - - void mtlSetTypeReflection(ID id, MTLTYPE_REFLECT type); - MTLTYPE_REFLECT mtlGetTypeReflection(ID id); - - - void mtlSetMaskTex(ID id, const char *szTexture); - void mtlGetMaskTex(ID id, char *szTexture); - - void mtlSetMRTex(ID id, int iChannel, const char *szTexture); - void mtlGetMRTex(ID id, int iChannel, char *szTexture); - - void mtlSetDTex(ID id, int iChannel, const char *szTexture); - void mtlGetDTex(ID id, int iChannel, char *szTexture); - - - void mtlSetStdVS(ID id, MTL_SHADERSTD type, bool isSend); - bool mtlGetStdVS(ID id, MTL_SHADERSTD type); - void mtlSetStdPS(ID id, MTL_SHADERSTD type, bool isSend); - bool mtlGetStdPS(ID id, MTL_SHADERSTD type); - - - void mtlSetUserDataVS(ID id, int iComponent, float val); - float mtlGetUserDataVS(ID id, int iComponent); - void mtlSetUserDataVS_InPS(ID id, bool isSendPS); - bool mtlGetUserDataVS_InPS(ID id); - void mtlSetUserDataPS(ID id, int iComponent, float fValue); - float mtlGetUserDataPS(ID id, int iComponent); - void mtlSetUserDataPS_InPS(ID id, bool isSendVS); - bool mtlGetUserDataPS_InPS(ID id); - - //********************************************************************** - - void mtlRefSetIDArr(ID id, ID idOwner, int iCube, ID idArr); - ID mtlRefGetIDArr(ID id, ID idOwner, int iCube); - - void mtlRefPreRenderPlane(ID id, D3DXPLANE *pPlane); - const IFrustum* mtlRefGetfrustum(ID id, int iCube); - void mtlRefPostRenderPlane(ID id); - IDirect3DTexture9* mtlRefPlaneGetTex(ID id); - - void mtlRefSetMinMax(ID id, const float3_t *pMin, const float3_t *pMax); - bool mtlRefIsAllowedRender(ID id); - - void mtlRefCubeBeginRender(ID id, const float3_t *pCenter); - void mtlRefCubePreRender(ID id, int iCube, const float4x4 *pWorld); - void mtlRefCubePostRender(ID id, int iCube); - void mtlRefCubeEndRender(ID id, const float3_t *pViewPos); - bool mtlRefUpdateCountUpdate(ID id, const float3_t *pViewPos); - void mtlRefNullingCountUpdate(ID id); - IDirect3DCubeTexture9* refCubeGetTex(ID id); - - //###################################################################### - - int delRefCount(); - ID delRefGetIDArr(ID idKey, ID idOwner, int iCube); - void delRefAllDel(); - - //###################################################################### - - struct CMaterial - { - CMaterial(); - ~CMaterial(); - - SX_ALIGNED_OP_MEM - - //! обнуление всех данных в материале - void nulling(); - - //! удален ли материал - bool m_isDelete; - - //! основные графические свойства - struct CMainGraphics - { - CMainGraphics(); - ~CMainGraphics(); - - //! основная текстура - ID m_idMainTexture; - - //! вершинный шейдер - ID m_idShaderVS; - - //! пиксельный шейдер - ID m_idShaderPS; - - //! неосвещаемый материал - bool m_isUnlit; - - //! использовать ли альфа тест - bool m_useAlphaTest; - - //! тип модели для рендера - MTLTYPE_MODEL type_model; - - //! отправляемые данные в шейдеры - struct СDataShader - { - СDataShader(); - ~СDataShader(); - - SX_ALIGNED_OP_MEM - - //! отправлять ли мировую матрицу - bool m_isTransWorld; - - //! отправлять ли видову матрицу - bool m_isTransView; - - //! отправлять ли проекционную матрицу - bool m_isTransProjection; - - //! отправлять ли world * view - bool m_isTransWorldView; - - //! отправлять ли world * view * projection - bool m_isTransWorldViewProjection; - - //! отправлять ли позицию камеры/наблюдателя - bool m_isTransPosCam; - - //! отправлять время кадра - bool m_isTransTimeDelta; - - //! отправлять ли пользовательские данные - bool m_isTransUserData; - - //! отправлять ли пользовательские данные в другой шейдер - bool m_isTransUserDataInOtherShader; - - //! отправлять ли размер окна рендера - bool m_isTransWinSize; - - //! пользовательские данные, значения [0, 1] - float4 m_vUserData; - }; - - //! отправляемые данные в вершинный шейдер - СDataShader m_oDataVS; - - //! отправляемые данные в пиксельный шейдер - СDataShader m_oDataPS; - }; - - //! детализированные свойства, маска и 4 детальных и 4 микрорельефных карты - struct CMaskDetailMicroRelief - { - CMaskDetailMicroRelief(); - ~CMaskDetailMicroRelief(); - - //! идентификатор текстуры маски, где к каждому каналу привязаны 4 детальных и микрорельефных текстуры - ID m_idMask; - - //! массив идентификаторов детальных текстур, для каждого канала маски - ID m_aDetail[4]; - - //! массив идентификаторов микрорельефных текстур (normal map), для каждого канала маски - ID m_aMicroRelief[4]; - }; - - //! световые свойсвта, основные характеристики просчета освещения - struct CLightParam - { - CLightParam(); - ~CLightParam(); - - //! текстура с параметрами материала (созданная пользователем) - ID m_idTexParam; - - //! текстура с параметрами материала, размер 1х1, параметры взяты из текущей структуры - ID m_idTexParamHand; - - //! назначена ли (true) текстура для параметров материала (или данные берем из параметров и кладем в рабочую текстуру) - bool m_isTextureParam; - - //! шероховатость [0 - гладкий, 1 - полностью шершавый] - float m_fRoughness; - - //! отражательная способность [0 - ничего не отражает, 1 - все отражает] - float m_fF0; - - //! толщина/просвечиваемость [0 - просвечивается, 1 - не просвечивается] - float m_fThickness; - - float m_fOldRoughness; - float m_fOldF0; - float m_fOldThickness; - - //! тип отражений - MTLTYPE_REFLECT m_type_reflect; - - //! тип прозрачности - MTLTYPE_TRANSPARENCY m_type_transparency; - }; - - - - //! физические свойства - struct CPhysics - { - CPhysics(); - ~CPhysics(); - - //! тип физического материала - MTLTYPE_PHYSIC type_physics; - - //! коэффициент пробиваемости [0, ], чем больше тем сложнее пробить - float m_fDurability; - - //! шанс пробиваемости [0 - пуля летит насквозь, 1 - пуля ударяется] - float m_fHitChance; - - //! плотность материала кг/м3 - float m_fDensity; - }; - - //! имя материала - String m_sName; - - //! основные графические свойства - CMainGraphics m_oMainGraphics; - - //! параметры детальности - CMaskDetailMicroRelief m_oMicroDetail; - - //! параметры освещения - CLightParam m_oLightParam; - - //! физические свойства - CPhysics m_oPhysics; - }; - - //! юнит материала - struct CUnitMaterial - { - CUnitMaterial(); - ~CUnitMaterial(); - - //! объект материала - CMaterial *m_pMtrl; - - //! объект отражений - CReflection *m_pReflect; - }; - -protected: - - //! использовать ли принудительный альфа тест - bool m_useForceblyAlphaTest; - - bool loadMtl(const char *szName, CMaterial **ppMtrl); - void createMtl(const char *szName, CMaterial **ppMtrl, MTLTYPE_MODEL type); - ID createTexParamLighting(float fRoughness, float fF0, float fThickness); - - void addName(const char *szName, ID id); - ID addUnitMaterial(CUnitMaterial *pUnitMtrl); - ID addMaterial(CMaterial *pMtrl); - - //! структура описывающая папку и все текстуры в ней, у каждой свой id для доступа - struct CPath - { - CPath(){} - - //! путь - String m_sPath; - - struct CObject - { - CObject(){ m_id = -1; } - CObject(ID id, const char *szName){ m_id = id; m_sName = szName; } - - //! идентификатор - ID m_id; - - //! имя - String m_sName; - }; - - //! массив CObject - Array m_aObjects; - }; - - //! массив путей до текстур/материалов - Array m_aMtrlPathes; - - //! массив юнитов материалов - Array m_aUnitMtrls; - - //! массив материалов - Array m_aMtrls; - - //! массив отражений - Array m_aReflections; - - //! использовать ли подсчет поверхностей - bool m_useCountSurface; - - //! текущий индентификатор поверхности - ID m_idCurrIdSurface; - - int CurrFirstFree; - - //! текущее время кадра в млсек - UINT m_uiCurrTimeDelta; - - //! общее время кадров в млсек - UINT m_uiCountTimeDelta; - - ID MtrlDefLight; - ID MtrlDefTree; - ID MtrlDefGrass; - ID MtrlDefStatic; - ID MtrlDefSkin; - ID BeginNonDef; - - float4x4 m_mWorld, m_mViewProj, m_mWorldTrans, m_mViewTrans, m_mProjTrans; -}; - -#endif \ No newline at end of file diff --git "a/source/mtllight/sxmtllight - \320\272\320\276\320\277\320\270\321\217.cpp" "b/source/mtllight/sxmtllight - \320\272\320\276\320\277\320\270\321\217.cpp" deleted file mode 100644 index e632478d2e45429952a41d6773df81bd6969c9a8..0000000000000000000000000000000000000000 --- "a/source/mtllight/sxmtllight - \320\272\320\276\320\277\320\270\321\217.cpp" +++ /dev/null @@ -1,1170 +0,0 @@ - -/*********************************************************** -Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 -See the license in LICENSE -***********************************************************/ - -#define SXMATERIAL_LIGTH_VERSION 1 - -#include "sxmtllight.h" -#include "ml_data.h" - -#include "light.h" -#include "material.h" - -#if !defined(DEF_STD_REPORT) -#define DEF_STD_REPORT -report_func g_fnReportf = DefReport; -#endif - -CLights* ArrLights = 0; -CMaterials* ArrMaterials = 0; - -#define ML_PRECOND(retval) if(!ArrLights){LibReport(-1, "%s - sxmtlligth is not init", GEN_MSG_LOCATION); return retval;} - -//########################################################################## - -SX_LIB_API long SML_0GetVersion() -{ - return SXMATERIAL_LIGTH_VERSION; -} - -SX_LIB_API void SML_Dbg_Set(report_func rf) -{ - g_fnReportf = rf; -} - -SX_LIB_API void SML_0Create(const char *szName, bool isUnic) -{ - if (szName && strlen(szName) > 1) - { - if (isUnic) - { - HANDLE hMutex = CreateMutex(NULL, FALSE, szName); - if (GetLastError() == ERROR_ALREADY_EXISTS) - { - CloseHandle(hMutex); - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - none unic name", GEN_MSG_LOCATION); - } - else - { - MLSet::MLInit(); - MLSet::ReCalcSize(); - ArrLights = new CLights(); - ArrMaterials = new CMaterials(); - } - } - else - { - MLSet::MLInit(); - MLSet::ReCalcSize(); - ArrLights = new CLights(); - ArrMaterials = new CMaterials(); - } - } - else - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - not init argument [name]", GEN_MSG_LOCATION); -} - -SX_LIB_API void SML_AKill() -{ - mem_delete(ArrLights) - mem_delete(ArrMaterials); -} - -SX_LIB_API void SML_OnLostDevice() -{ - ML_PRECOND(_VOID); - ArrLights->onLostDevice(); - ArrMaterials->onLostDevice(); -} - -SX_LIB_API void SML_OnResetDevice() -{ - ML_PRECOND(_VOID); - - MLSet::ReCalcSize(); - ArrLights->onResetDevice(); - ArrMaterials->onResetDevice(); - - MLSet::IDsRenderTargets::HowAdaptedLum = 0; -} - -SX_LIB_API void SML_Update(DWORD timeDelta) -{ - static const int *r_win_width = GET_PCVAR_INT("r_win_width"); - static const int *r_win_height = GET_PCVAR_INT("r_win_height"); - - static const float *r_default_fov = GET_PCVAR_FLOAT("r_default_fov"); - - if (ArrMaterials) - ArrMaterials->update(timeDelta); - - MLSet::RefMProjPlane = SMMatrixPerspectiveFovLH(*r_default_fov, float(*r_win_width) / float(*r_win_height), MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); - MLSet::RefMProjCube = SMMatrixPerspectiveFovLH(SM_PI * 0.5f, 1, MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); -} - -SX_LIB_API void SML_LigthsSettLCoefSizeDepth(float fCoef) -{ - ML_PRECOND(_VOID); - - MLSet::CoefSizeDepthMapForLocal = fCoef; - MLSet::ReCalcSize(); - SML_OnLostDevice(); - SML_OnResetDevice(); -} - -SX_LIB_API void SML_LigthsSettGCoefSizeDepth(float fCoef) -{ - ML_PRECOND(_VOID); - - MLSet::CoefSizeDepthMapForGlobal = fCoef; - MLSet::ReCalcSize(); - SML_OnLostDevice(); - SML_OnResetDevice(); - -} - -SX_LIB_API float SML_LigthsGettLCoefSizeDepth() -{ - ML_PRECOND(-1); - - return MLSet::CoefSizeDepthMapForLocal; -} - -SX_LIB_API float SML_LigthsGettGCoefSizeDepth() -{ - ML_PRECOND(-1); - return MLSet::CoefSizeDepthMapForGlobal; -} - -//############################################################################# - -SX_LIB_API void SML_LigthsClear() -{ - ML_PRECOND(_VOID); - - ArrLights->clear(); -} - -SX_LIB_API void SML_LigthsClearIDArr() -{ - ML_PRECOND(_VOID); - - ArrLights->clearIDArr(); -} - -SX_LIB_API int SML_LigthsGetCount() -{ - ML_PRECOND(-1); - - return ArrLights->getCountLights(); -} - -SX_LIB_API bool SML_LigthsGetExists(ID id) -{ - ML_PRECOND(false); - - return ArrLights->getExists(id); -} - - -SX_LIB_API ID SML_LigthsCreatePoint(const float3 *pCenter, float fDist, const float3 *pColor, bool isGlobal, bool isShadowed/*, const char* bound_volume*/) -{ - ML_PRECOND(-1); - return ArrLights->createPoint(-1, pCenter, fDist, pColor, isGlobal, isShadowed/*, 0*/); -} - -SX_LIB_API ID SML_LigthsCreateDirection(const float3 *pPos, float fDist, const float3 *pColor, const SMQuaternion *qOrient, float fTopRadius, float fAngle, bool isShadow/*, const char* bound_volume*/) -{ - ML_PRECOND(-1); - return ArrLights->createDirection(-1, pPos, fDist, pColor, qOrient, fTopRadius, fAngle, isShadow/*, 0*/); -} - -SX_LIB_API void SML_LigthsRender(ID id, DWORD timeDelta) -{ - ML_PRECOND(_VOID); - ArrLights->render(id, timeDelta); -} - -SX_LIB_API ID SML_LigthsGetGlobal() -{ - ML_PRECOND(-1); - return ArrLights->getLightGlobal(); -} - -SX_LIB_API bool SML_LigthsGetCastGlobalShadow() -{ - ML_PRECOND(false); - return ArrLights->getCastGlobalShadow(); -} - -SX_LIB_API void SML_LigthsSetCastGlobalShadow(bool isShadowed) -{ - ML_PRECOND(_VOID); - return ArrLights->setCastGlobalShadow(isShadowed); -} - -SX_LIB_API void SML_LigthsGetColor(ID id, float3 *pColor) -{ - ML_PRECOND(_VOID); - ArrLights->getLightColor(id, pColor); -} - -SX_LIB_API void SML_LigthsSetColor(ID id, const float3 *pColor) -{ - ML_PRECOND(_VOID); - ArrLights->setLightColor(id, pColor); -} - -SX_LIB_API void SML_LigthsGetPos(ID id, float3 *pPos, bool isGreal) -{ - ML_PRECOND(_VOID); - ArrLights->getLightPos(id, pPos, isGreal); -} - -SX_LIB_API float SML_LigthsGetPower(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightPower(id); -} - -SX_LIB_API float SML_LigthsGetDist(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightDist(id); -} - -SX_LIB_API void SML_LigthsSetPos(ID id, const float3 *pPos, bool isGreal) -{ - ML_PRECOND(_VOID); - ArrLights->setLightPos(id, pPos, isGreal); -} - -SX_LIB_API void SML_LigthsGetOrient(ID id, SMQuaternion *pQ) -{ - ML_PRECOND(_VOID); - ArrLights->getLightOrient(id, pQ); -} - -SX_LIB_API void SML_LigthsSetOrient(ID id, const SMQuaternion *pQ) -{ - ML_PRECOND(_VOID); - ArrLights->setLightOrient(id, pQ); -} - -SX_LIB_API LTYPE_LIGHT SML_LigthsGetType(ID id) -{ - ML_PRECOND(LTYPE_LIGHT_NONE); - return ArrLights->getLightType(id); -} - -SX_LIB_API bool SML_LigthsComVisibleForFrustum(ID id, const IFrustum *pFrustum) -{ - ML_PRECOND(-1); - return ArrLights->comVisibleForFrustum(id, pFrustum); -} - -SX_LIB_API bool SML_LigthsGetVisibleForFrustum(ID id) -{ - ML_PRECOND(false); - return ArrLights->getVisibleForFrustum(id); -} - -SX_LIB_API float SML_LigthsComDistFor(ID id, const float3 *pPos) -{ - ML_PRECOND(-1); - return ArrLights->comDistFor(id, pPos); -} - -SX_LIB_API float SML_LigthsGetDistFor(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getDistFor(id); -} - -SX_LIB_API void SML_LigthsComVisibleFrustumDistFor(const IFrustum *pFrustum, const float3 *pPos) -{ - ML_PRECOND(_VOID); - return ArrLights->comVisibleFrustumDistFor(pFrustum, pPos); -} - -SX_LIB_API bool SML_LigthsGetEnable(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightEnable(id); -} - -SX_LIB_API void SML_LigthsSetEnable(ID id, bool isEnable) -{ - ML_PRECOND(_VOID); - return ArrLights->setLightEnable(id, isEnable); -} - -SX_LIB_API bool SML_LigthsGetShadowed(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightShadowed(id); -} - -SX_LIB_API bool SML_LigthsGet4Or3SplitsG(ID id) -{ - ML_PRECOND(0); - return ArrLights->get4Or3Splits(id); -} - -SX_LIB_API void SML_LigthsSet4Or3SplitsG(ID id, bool is4or3) -{ - ML_PRECOND(_VOID); - - ArrLights->set4Or3Splits(id, is4or3); -} - -SX_LIB_API IDirect3DTexture9* SML_LigthsGetShadow() -{ - ML_PRECOND(0); - return ArrLights->getShadow2(); -} - -SX_LIB_API void SML_LigthsShadowNull() -{ - ML_PRECOND(_VOID); - return ArrLights->shadowNull(); -} - -SX_LIB_API void SML_LigthsShadowRenderBegin(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->shadowRenderBegin(id); -} - -SX_LIB_API void SML_LigthsShadowRenderEnd(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->shadowRenderEnd(id); -} - -SX_LIB_API void SML_LigthsShadowRenderPre(ID id, int iCube) -{ - ML_PRECOND(_VOID); - ArrLights->shadowRenderPre(id, iCube); -} - -SX_LIB_API void SML_LigthsShadowRenderPost(ID id, int iCube) -{ - ML_PRECOND(_VOID); - ArrLights->shadowRenderPost(id, iCube); -} - -SX_LIB_API IFrustum* SML_LigthsGetFrustum(ID id, int iHow) -{ - ML_PRECOND(0); - return ArrLights->getLightFrustum(id, iHow); -} - -SX_LIB_API void SML_LigthsUpdateGFrustums(ID id, int iSplit, const float3 *pPos, const float3 *pDir) -{ - ML_PRECOND(_VOID); - return ArrLights->updateLightGFrustums(id, iSplit, pPos, pDir); -} - -SX_LIB_API void SML_LigthsShadowSetShaderOfTypeMat(ID id, int iTypeMaterial, const float4x4 *pWorld) -{ - ML_PRECOND(_VOID); - ArrLights->initShaderOfTypeMaterial(id, iTypeMaterial, pWorld); -} - -SX_LIB_API void SML_LigthsShadowGen(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->shadowGen2(id); -} - -SX_LIB_API void SML_LigthsShadowSoft(bool isRandom, float fSize, bool isFirst) -{ - ML_PRECOND(_VOID); - ArrLights->shadowSoft(isRandom, fSize, isFirst); -} - - - -SX_LIB_API ID SML_LigthsCreateCopy(ID id) -{ - ML_PRECOND(-1); - return ArrLights->createCopy(id); -} - -SX_LIB_API void SML_LigthsDeleteLight(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->deleteLight(id); -} - -SX_LIB_API char* SML_LigthsGetName(ID id) -{ - ML_PRECOND(0); - return ArrLights->getLightName(id); -} - -SX_LIB_API void SML_LigthsSetName(ID id, const char *szName) -{ - ML_PRECOND(_VOID); - ArrLights->setLightName(id, szName); -} - - -SX_LIB_API void SML_LigthsSetAngle(ID id, float fAngle) -{ - ML_PRECOND(_VOID); - ArrLights->setLightAngle(id, fAngle, true); -} - -SX_LIB_API void SML_LigthsSetTopRadius(ID id, float fTopRadius) -{ - ML_PRECOND(_VOID); - ArrLights->setLightTopRadius(id, fTopRadius); -} - -SX_LIB_API void SML_LigthsSetDist(ID id, float fRadiusHeight, bool isCreate) -{ - ML_PRECOND(_VOID); - ArrLights->setLightDist(id, fRadiusHeight, isCreate); -} - - -SX_LIB_API float SML_LigthsGetShadowBias(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getShadowBias(id); -} - -SX_LIB_API void SML_LigthsSetShadowBias(ID id, float fBias) -{ - ML_PRECOND(_VOID); - return ArrLights->setShadowBias(id, fBias); -} - -SX_LIB_API void SML_LigthsSetShadowBlurPixel(ID id, float fBlurPixel) -{ - ML_PRECOND(_VOID); - ArrLights->setShadowBlurPixel(id, fBlurPixel); -} - -SX_LIB_API float SML_LigthsGetShadowBlurPixel(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getShadowBlurPixel(id); -} -SX_LIB_API void SML_LigthsSetShadowLocalNear(ID id, float fNear) -{ - ML_PRECOND(_VOID); - ArrLights->setShadowLocalNear(id, fNear); -} - -SX_LIB_API float SML_LigthsGetShadowLocalNear(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getShadowLocalNear(id); -} - -SX_LIB_API void SML_LigthsSetShadowLocalFar(ID id, float fFar) -{ - ML_PRECOND(_VOID); - ArrLights->setShadowLocalFar(id, fFar); -} - -SX_LIB_API float SML_LigthsGetShadowLocalFar(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getShadowLocalFar(id); -} - -SX_LIB_API void SML_LigthsSetCubeEdgeEnable(ID id, int iEdge, bool isEnable) -{ - ML_PRECOND(_VOID); - ArrLights->setLightCubeEdgeEnable(id, iEdge, isEnable); -} - -SX_LIB_API bool SML_LigthsGetCubeEdgeEnable(ID id, int iEdge) -{ - ML_PRECOND(false); - return ArrLights->getLightCubeEdgeEnable(id, iEdge); -} - - -SX_LIB_API float SML_LigthsGetAngle(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightAngle(id); -} - -SX_LIB_API float SML_LigthsGetTopRadius(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightTopRadius(id); -} - -SX_LIB_API ID SML_LigthsGetIDArr(ID id, ID idOwner, int iHow) -{ - ML_PRECOND(-1); - return ArrLights->getLightIDArr(id, idOwner, iHow); -} - -SX_LIB_API void SML_LigthsSetIDArr(ID id, ID idOwner, int iHow, ID idArr) -{ - ML_PRECOND(_VOID); - ArrLights->setLightIDArr(id, idOwner, iHow, idArr); -} - -SX_LIB_API void SML_LigthsSetTypeShadowed(ID id, LTYPE_SHADOW type) -{ - ML_PRECOND(_VOID); - ArrLights->setLightTypeShadowed(id, type); -} - -SX_LIB_API LTYPE_SHADOW SML_LigthsGetTypeShadowed(ID id) -{ - ML_PRECOND(LTYPE_SHADOW_NONE); - return ArrLights->getLightTypeShadowed(id); -} - -SX_LIB_API bool SML_LigthsCountUpdateUpdate(ID id, const float3 *pViewPos, int iHow) -{ - ML_PRECOND(false); - return ArrLights->lightCountUpdateUpdate(id, pViewPos, iHow); -} - -SX_LIB_API bool SML_LigthsCountUpdateAllowed(ID id, int iHow) -{ - ML_PRECOND(false); - return ArrLights->lightCountUpdateAllowed(id, iHow); -} - -SX_LIB_API void SML_LigthsCountUpdateNull(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->lightCountUpdateNull(id); -} - -SX_LIB_API void SML_LigthsToneMappingCom(DWORD timeDelta, float fAdapted) -{ - ML_PRECOND(_VOID); - ArrLights->toneMappingCom(timeDelta, fAdapted); -} - -SX_LIB_API int SML_LigthsDelGetCount() -{ - ML_PRECOND(-1); - return ArrLights->delGetCount(); -} - -SX_LIB_API LTYPE_LIGHT SML_LigthsDelGetType(ID idKey) -{ - ML_PRECOND(LTYPE_LIGHT_NONE); - return ArrLights->delGetType(idKey); -} - -SX_LIB_API void SML_LigthsDelDel(ID idKey) -{ - ML_PRECOND(_VOID); - ArrLights->delDel(idKey); -} - -SX_LIB_API ID SML_LigthsDelGetIDArr(ID idKey, ID idOwner, int iHow) -{ - ML_PRECOND(-1); - return ArrLights->delGetIDArr(idKey, idOwner, iHow); -} - -//############################################################################# - -SX_LIB_API ID SML_DSGetRT_ID(DS_RT type) -{ - ML_PRECOND(-1); - if (type == DS_RT_COLOR) - return MLSet::IDsRenderTargets::ColorScene; - else if (type == DS_RT_NORMAL) - return MLSet::IDsRenderTargets::NormalScene; - else if (type == DS_RT_PARAM) - return MLSet::IDsRenderTargets::ParamsScene; - else if (type == DS_RT_DEPTH) - return MLSet::IDsRenderTargets::DepthScene; - else if (type == DS_RT_DEPTH0) - return MLSet::IDsRenderTargets::DepthScene0; - else if (type == DS_RT_DEPTH1) - return MLSet::IDsRenderTargets::DepthScene1; - - else if (type == DS_RT_AMBIENTDIFF) - return MLSet::IDsRenderTargets::LightAmbientDiff; - else if (type == DS_RT_SPECULAR) - return MLSet::IDsRenderTargets::LightSpecular; - - else if (type == DS_RT_SCENELIGHT) - return MLSet::IDsRenderTargets::LigthCom; - else if (type == DS_RT_SCENELIGHT2) - return MLSet::IDsRenderTargets::LigthCom2; - - else if (type == DS_RT_ADAPTEDLUM) - return MLSet::IDsRenderTargets::GetCurrAdaptedLum(); - - return -1; -} - -SX_LIB_API IDirect3DTexture9* SML_DSGetRT(DS_RT type) -{ - ML_PRECOND(0); - - ID tmpid = SML_DSGetRT_ID(type); - if (tmpid >= 0) - return SGCore_RTGetTexture(tmpid); - else - return 0; -} - -//############################################################################# - -SX_LIB_API ID SML_MtlLoad(const char *szName, MTLTYPE_MODEL mtl_type) -{ - ML_PRECOND(-1); - - return ArrMaterials->mtlLoad(szName, mtl_type); -} - -SX_LIB_API void SML_MtlSave(ID id) -{ - ML_PRECOND(_VOID); - - ArrMaterials->mtlSave(id); -} - -SX_LIB_API MTLTYPE_MODEL SML_MtlGetTypeModel(ID id) -{ - ML_PRECOND(MTLTYPE_MODEL_STATIC); - - return ArrMaterials->getTypeModel(id); -} - -SX_LIB_API void SML_MtlSetTypeModel(ID id, MTLTYPE_MODEL type_model) -{ - ML_PRECOND(_VOID); - - ArrMaterials->setTypeModel(id, type_model); -} - -SX_LIB_API long SML_MtlGetCount() -{ - ML_PRECOND(-1); - - return ArrMaterials->getCount(); -} - -SX_LIB_API void SML_MtlRender(ID id, const float4x4 *pWorld) -{ - ML_PRECOND(_VOID); - ArrMaterials->render(id, pWorld); -} - -SX_LIB_API void SML_MtlRenderStd(MTLTYPE_MODEL type, const float4x4 *pWorld, ID idSlot, ID idMtl) -{ - ML_PRECOND(_VOID); - ArrMaterials->renderStd(type, pWorld, idSlot, idMtl); -} - -SX_LIB_API void SML_MtlRenderLight(const float4_t *pColor, const float4x4 *pWorld) -{ - ML_PRECOND(_VOID); - ArrMaterials->renderLight(pColor, pWorld); -} - -SX_LIB_API void SML_MtlSetMainTexture(ID slot, ID id) -{ - ML_PRECOND(_VOID); - ArrMaterials->setMainTexture(slot, id); -} - -SX_LIB_API void SML_MtlSetIsIncrCountSurf(bool bf) -{ - ML_PRECOND(_VOID); - ArrMaterials->setIsIncrCountSurf(bf); -} - -SX_LIB_API bool SML_MtlGetIsIncrCountSurf() -{ - ML_PRECOND(false); - return ArrMaterials->getIsIncrCountSurf(); -} - -SX_LIB_API void SML_MtlNullingCurrCountSurf() -{ - ML_PRECOND(_VOID); - ArrMaterials->nullingCurrCountSurf(); -} - -SX_LIB_API int SML_MtlGetCurrCountSurf() -{ - ML_PRECOND(-1); - return ArrMaterials->getCurrCountSurf(); -} - -SX_LIB_API void SML_MtlSetCurrCountSurf(int iCount) -{ - ML_PRECOND(_VOID); - ArrMaterials->setCurrCountSurf(iCount); -} - -SX_LIB_API void SML_MtlSetForceblyAlphaTest(bool isAlphaTest) -{ - ML_PRECOND(_VOID); - ArrMaterials->setForceblyAlphaTest(isAlphaTest); -} - -SX_LIB_API bool SML_MtlGetForceblyAlphaTest() -{ - ML_PRECOND(false); - return ArrMaterials->getForceblyAlphaTest(); -} - - -SX_LIB_API ID SML_MtlGetStdMtl(MTLTYPE_MODEL type_model) -{ - ML_PRECOND(-1); - return ArrMaterials->getStdMtl(type_model); -} - - -SX_LIB_API void SML_MtlSetPhysicMaterial(ID id, MTLTYPE_PHYSIC type) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetPhysicMaterial(id, type); -} - -SX_LIB_API MTLTYPE_PHYSIC SML_MtlGetPhysicMaterial(ID id) -{ - ML_PRECOND(MTLTYPE_PHYSIC_DEFAULT); - return ArrMaterials->mtlGetPhysicMaterial(id); -} - -SX_LIB_API bool SML_MtlGetUsingAlphaTest(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetUsingAlphaTest(id); -} - -SX_LIB_API void SML_MtlSetUsingAlphaTest(ID id, bool isUsing) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUsingAlphaTest(id, isUsing); -} - - - -SX_LIB_API void SML_MtlRefSetIDArr(ID id, ID idOwner, int iCube, ID idArr) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefSetIDArr(id, idOwner, iCube, idArr); -} - -SX_LIB_API ID SML_MtlRefGetIDArr(ID id, ID idOwner, int iCube) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlRefGetIDArr(id, idOwner, iCube); -} - -SX_LIB_API int SML_MtlDelRefGetCount() -{ - ML_PRECOND(-1); - return ArrMaterials->delRefCount(); -} - -SX_LIB_API ID SML_MtlDelRefGetIDArr(ID idKey, ID idOwner, int iCube) -{ - ML_PRECOND(-1); - return ArrMaterials->delRefGetIDArr(idKey, idOwner, iCube); -} - -SX_LIB_API void SML_MtlDelRefClear() -{ - ML_PRECOND(_VOID); - ArrMaterials->delRefAllDel(); -} - -SX_LIB_API void SML_MtlRefSetMinMax(ID id, const float3_t *pMin, const float3_t *pMax) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefSetMinMax(id, pMin, pMax); -} - -SX_LIB_API void SML_MtlRefPreRenderPlane(ID id, D3DXPLANE *pPlane) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefPreRenderPlane(id, pPlane); -} - -SX_LIB_API const IFrustum* SML_MtlRefGetfrustum(ID id, int iCube) -{ - ML_PRECOND(0); - return ArrMaterials->mtlRefGetfrustum(id, iCube); -} - -SX_LIB_API bool SML_MtlRefIsAllowedRender(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlRefIsAllowedRender(id); -} - -SX_LIB_API void SML_MtlRefPostRenderPlane(ID id) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefPostRenderPlane(id); -} - -SX_LIB_API IDirect3DTexture9* SML_MtlRefGetTexPlane(ID id) -{ - ML_PRECOND(0); - return ArrMaterials->mtlRefPlaneGetTex(id); -} - - - -SX_LIB_API void SML_MtlRefCubeBeginRender(ID id, const float3_t *pCenter) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefCubeBeginRender(id, pCenter); -} - -SX_LIB_API void SML_MtlRefCubePreRender(ID id, int iCube, const float4x4 *pWorld) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefCubePreRender(id, iCube, pWorld); -} - -SX_LIB_API void SML_MtlRefCubePostRender(ID id, int iCube) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefCubePostRender(id, iCube); -} - -SX_LIB_API void SML_MtlRefCubeEndRender(ID id, const float3_t *pViewPos) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefCubeEndRender(id, pViewPos); -} - -SX_LIB_API bool SML_MtlRefUpdateCountUpdate(ID id, const float3_t *pViewPos) -{ - ML_PRECOND(false); - return ArrMaterials->mtlRefUpdateCountUpdate(id, pViewPos); -} - -SX_LIB_API void SML_MtlRefNullingCountUpdate(ID id) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefNullingCountUpdate(id); -} - -SX_LIB_API IDirect3DCubeTexture9* SML_MtlRefCubeGetTex(ID id) -{ - ML_PRECOND(0); - return ArrMaterials->refCubeGetTex(id); -} - -//########################################################################## - -SX_LIB_API void SML_MtlReloadMaterial(ID id, const char *szName) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlReLoad(id, szName); -} - -SX_LIB_API void SML_MtlClear(bool isClearRefDel) -{ - ML_PRECOND(_VOID); - ArrMaterials->clear(isClearRefDel); -} - -SX_LIB_API void SML_MtlSetTexture(ID id, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetTexture(id, szTexture); -} - -SX_LIB_API void SML_MtlGetTexture(ID id, char *szName) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetTexture(id, szName); -} - -SX_LIB_API ID SML_MtlGetTextureID(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetTextureID(id); -} - -SX_LIB_API void SML_MtlSetVS(ID id, const char *szPath) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetVS(id, szPath); -} - -SX_LIB_API void SML_MtlGetVS(ID id, char *szName) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetVS(id, szName); -} - -SX_LIB_API void SML_MtlSetPS(ID id, const char *szPath) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetPS(id, szPath); -} - -SX_LIB_API void SML_MtlGetPS(ID id, char *szName) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetPS(id, szName); -} - -SX_LIB_API float SML_MtlGetDurability(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetDurability(id); -} - -SX_LIB_API void SML_MtlSetDurability(ID id, float fDurability) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetDurability(id, fDurability); -} - -SX_LIB_API float SML_MtlGetHitChance(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetHitChance(id); -} - -SX_LIB_API void SML_MtlSetHitChance(ID id, float fHitChance) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetHitChance(id, fHitChance); -} - -SX_LIB_API float SML_MtlGetDensity(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetDensity(id); -} - -SX_LIB_API void SML_MtlSetDensity(ID id, float fDensity) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetDensity(id, fDensity); -} - -//########################################################################## - -SX_LIB_API void SML_MtlSetLighting(ID id, bool isLighting) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetLighting(id, isLighting); -} - -SX_LIB_API bool SML_MtlGetLighting(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetLighting(id); -} - -SX_LIB_API void SML_MtlSetIsTextureLighting(ID id, bool isTexLighting) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetIsTextureLighting(id, isTexLighting); -} - -SX_LIB_API bool SML_MtlGetIsTextureLighting(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetIsTextureLighting(id); -} - -SX_LIB_API void SML_MtlSetTextureLighting(ID id, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetTextureLighting(id, szTexture); -} - -SX_LIB_API void SML_MtlGetTextureLighting(ID id, char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetTextureLighting(id, szTexture); -} - -SX_LIB_API void SML_MtlSetRoughness(ID id, float fRoughness) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetRoughness(id, fRoughness); -} - -SX_LIB_API float SML_MtlGetRoughness(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetRoughness(id); -} - -SX_LIB_API void SML_MtlSetThickness(ID id, float fThickness) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetThickness(id, fThickness); -} - -SX_LIB_API float SML_MtlGetThickness(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetThickness(id); -} - -SX_LIB_API void SML_MtlSetF0(ID id, float fF0) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetF0(id, fF0); -} - -SX_LIB_API float SML_MtlGetF0(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetF0(id); -} - -SX_LIB_API void SML_MtlSetTypeTransparency(ID id, MTLTYPE_TRANSPARENCY type) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetTypeTransparency(id, type); -} - -SX_LIB_API MTLTYPE_TRANSPARENCY SML_MtlGetTypeTransparency(ID id) -{ - ML_PRECOND(MTLTYPE_TRANSPARENCY_NONE); - return ArrMaterials->mtlGetTypeTransparency(id); -} - -SX_LIB_API void SML_MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetTypeReflection(id, type); -} - -SX_LIB_API MTLTYPE_REFLECT SML_MtlGetTypeReflection(ID id) -{ - ML_PRECOND(MTLTYPE_REFLECT_NONE); - return ArrMaterials->mtlGetTypeReflection(id); -} - -//************************************************************************** - -SX_LIB_API void SML_MtlSetMaskTex(ID id, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetMaskTex(id, szTexture); -} - -SX_LIB_API void SML_MtlGetMaskTex(ID id, char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetMaskTex(id, szTexture); -} - -SX_LIB_API void SML_MtlSetMRTex(ID id, int iChannel, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetMRTex(id, iChannel, szTexture); -} - -SX_LIB_API void SML_MtlGetMRTex(ID id, int iChannel, char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetMRTex(id, iChannel, szTexture); -} - -SX_LIB_API void SML_MtlSetDTex(ID id, int iChannel, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetDTex(id, iChannel, szTexture); -} - -SX_LIB_API void SML_MtlGetDTex(ID id, int iChannel, char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetDTex(id, iChannel, szTexture); -} - -SX_LIB_API void SML_MtlSetStdVS(ID id, MTL_SHADERSTD type, bool isSend) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetStdVS(id, type, isSend); -} - -SX_LIB_API bool SML_MtlGetStdVS(ID id, MTL_SHADERSTD type) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetStdVS(id, type); -} - -SX_LIB_API void SML_MtlSetStdPS(ID id, MTL_SHADERSTD type, bool isSend) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetStdPS(id, type, isSend); -} - -SX_LIB_API bool SML_MtlGetStdPS(ID id, MTL_SHADERSTD type) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetStdPS(id, type); -} - - -SX_LIB_API void SML_MtlSetUserDataVS(ID id, int iComponent, float fValue) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUserDataVS(id, iComponent, fValue); -} - -SX_LIB_API float SML_MtlGetUserDataVS(ID id, int iComponent) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetUserDataVS(id, iComponent); -} - -SX_LIB_API void SML_MtlSetUserDataVS_InPS(ID id, bool isSendPS) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUserDataVS_InPS(id, isSendPS); -} - -SX_LIB_API bool SML_MtlGetUserDataVS_InPS(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetUserDataVS_InPS(id); -} - -SX_LIB_API void SML_MtlSetUserDataPS(ID id, int iComponent, float fValue) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUserDataPS(id, iComponent, fValue); -} - -SX_LIB_API float SML_MtlGetUserDataPS(ID id, int iComponent) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetUserDataPS(id, iComponent); -} - -SX_LIB_API void SML_MtlSetUserDataPS_InVS(ID id, bool isSendVS) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUserDataPS_InPS(id, isSendVS); -} - -SX_LIB_API bool SML_MtlGetUserDataPS_InVS(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetUserDataPS_InPS(id); -} diff --git "a/source/mtllight/sxmtllight - \320\272\320\276\320\277\320\270\321\217.h" "b/source/mtllight/sxmtllight - \320\272\320\276\320\277\320\270\321\217.h" deleted file mode 100644 index 6092009aa0964006a887c3f450af4e4e7800308d..0000000000000000000000000000000000000000 --- "a/source/mtllight/sxmtllight - \320\272\320\276\320\277\320\270\321\217.h" +++ /dev/null @@ -1,1362 +0,0 @@ - -/*********************************************************** -Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 -See the license in LICENSE -***********************************************************/ - -/*! -\file -Заголовочный файл sxmtllight - библиотеки освещения и материалов -*/ - -/*! \defgroup sxmtllight sxmtllight - библиотека освещения и материалов -@{ -*/ - -#ifndef __SXMTLLIGHT_H -#define __SXMTLLIGHT_H - -#if defined(_DEBUG) -#pragma comment(lib, "sxgcore_d.lib") -#else -#pragma comment(lib, "sxgcore.lib") -#endif - -#undef SX_LIB_API -#define SX_LIB_API extern "C" __declspec (dllimport) -#include - -#ifdef SX_DLL -#undef SX_LIB_API -#define SX_LIB_API extern "C" __declspec (dllexport) -#endif - -#include - -/*! \name Базовые функции библиотеки -@{*/ - -//! версия подсистемы -SX_LIB_API long SML_0GetVersion(); - -//! установить функцию обработки сообщений -SX_LIB_API void SML_Dbg_Set(report_func rf); - -//! инициализция подсистемы -SX_LIB_API void SML_0Create( - const char *szName, //!< присваиваемое имя - bool isUnic = true //!< должна ли подсистема быть уникальной по имени - ); - -//! уничтожить подсистему -SX_LIB_API void SML_AKill(); - -//!@} - -/*! \name Обработка потери/восстановления устройства -@{*/ - -//! вызывать при потрете устройства -SX_LIB_API void SML_OnLostDevice(); - -//! вызывать при восстановлении устройства -SX_LIB_API void SML_OnResetDevice(); - -//!@} - -//! обновление данных всей библиотеки -SX_LIB_API void SML_Update( - DWORD timeDelta //!< время рендера кадра в млсек - ); - -//############################################################################# - -/*! \defgroup sxmtllight_light Освещение - \ingroup sxmtllight - \warning Обращение (идентификация) конкретного света осуществляется посредством идентификатора который выдают создающие функции: - - #SML_LigthsCreatePoint - - #SML_LigthsCreateDirection - Получить идентификатор уже созданного света можно, посредством ключа (key) который лежит в пределах [0, #SML_LigthsGetCount), -передав этот ключ #SML_LigthsGetIDOfKey, которая в случае успеха вернет идентификатор света. -@{*/ - -/*! максимальное количество обновлений статических источников света, в первый момент рендера */ -#define LIGHTS_UPDATE_MAX_COUNT_FOR_STATIC 3 - -/*! \name Дистанции (метрах) при которых будет сниженно или повышено количество отрисовок для локальных источников света -меньше #LIGHTS_UPDATE_L0_DIST - обновление будет каждый кадр\n -больше #LIGHTS_UPDATE_L2_DIST - обновления не будет -@{*/ - -#define LIGHTS_UPDATE_L0_DIST 10 -#define LIGHTS_UPDATE_L1_DIST 30 -#define LIGHTS_UPDATE_L2_DIST 70 - -//!@} - -/*! Коэфициент обновления сплитов глобального света. -Cчитается: LIGHTS_UPDATE_PSSM_SPLIT*number_split - \note Первый сплит обновляется каждый кадр, второй через кадр -*/ -#define LIGHTS_UPDATE_PSSM_SPLIT 1 - -/*! аналогичнен #LIGHTS_UPDATE_PSSM_SPLIT только для 5 сплита (для теней от облаков) */ -#define LIGHTS_UPDATE_PSSM_SPLIT_5 2 - - -/*! стандартное значение верхнего/начального радиуса для направленного света */ -#define LIGHTS_LOCAL_STD_TOP_RADIUS 0.1 - -/*! стандартное значение ближней плоскости отсечения для теней локального света */ -#define LIGHTS_LOCAL_STD_NEAR 0.1 - -/*! максимальная дистанция локального света */ -#define LIGHTS_LOCAL_MAX_DIST 200.f - - -/*! радиус глобального источника */ -#define LIGHTS_GLOBAL_STD_RADIUS 999999 - -/*! отдаленность глобального света (нужно для корректности теней), если не знаете, не трогайте */ -#define LIGHTS_POS_G_MAX 1000 - - -/*! базовое направление направленноого источника света */ -#define LIGHTS_DIR_BASE float3(0, -1, 0) - - -//! типы источников света -enum LTYPE_LIGHT -{ - //! не установленный - LTYPE_LIGHT_NONE = -1, - - //! глобальный - LTYPE_LIGHT_GLOBAL, - - //! точечный - LTYPE_LIGHT_POINT, - - //! направленный - LTYPE_LIGHT_DIR -}; - -//! типы теней источников света -enum LTYPE_SHADOW -{ - //! без теней - LTYPE_SHADOW_NONE = -1, - - //! статичные тени, тень обновляется первые несколько кадров (для корректности), далее не обновляется - LTYPE_SHADOW_STATIC, - - //! полностью динамические тени - LTYPE_SHADOW_DYNAMIC, -}; - -/*! \name Настройки размеров для теней - \note Коэфициента относительно размеров окна рендера, если 1.f то размеры экрана, если 0.5f то размеры экрана * 0.5f -@{*/ - -//! установка коэфициента для локального света -SX_LIB_API void SML_LigthsSettLCoefSizeDepth(float fCoef); - -//! установка коэфициента для глобального света -SX_LIB_API void SML_LigthsSettGCoefSizeDepth(float fCoef); - - -//! возвращение коэфициента для локальный свет -SX_LIB_API float SML_LigthsGettLCoefSizeDepth(); - -//! возвращение коэфициента для глобальный свет -SX_LIB_API float SML_LigthsGettGCoefSizeDepth(); - -//!@} - -//! очистить список света -SX_LIB_API void SML_LigthsClear(); - -//! очистка всех идентификаторов просчетов во всех источниках света -SX_LIB_API void SML_LigthsClearIDArr(); - -//! общее количество света -SX_LIB_API int SML_LigthsGetCount(); - -//! возвращает true если свет с id существует -SX_LIB_API bool SML_LigthsGetExists(ID id); - -//! создать точечный свет (светит во все стороны) -SX_LIB_API ID SML_LigthsCreatePoint( - const float3 *pCenter, //!< центр света (мировая позиция) - float fDist, //!< дистанция, на которую распространяется свет - const float3 *pColor, //!< цвет в пределах 0-1 - bool isGlobal, //!< глобальный ли свет (типа солнца) - bool isShadowed //!< отбрасвыает ли тени свет - ); - -//! создать направленный свет -SX_LIB_API ID SML_LigthsCreateDirection( - const float3 *pPos, //!< позиция света (мировая) - float fDist, //!< дистанция на которую распространяется свет - const float3 *pColor, //!< цвет - const SMQuaternion *qOrient,//!< ориентация - float fTopRadius, //!< верхний (начальный) радиус - float fAngle, //!< угол (в радианах) - bool isShadow //!< отбрасвыает ли тени свет - ); - -//! возвращает тип света -SX_LIB_API LTYPE_LIGHT SML_LigthsGetType(ID id); - -//! создать копию объекта и вернуть на нее id -SX_LIB_API ID SML_LigthsCreateCopy(ID id); - -//! удаление света -SX_LIB_API void SML_LigthsDeleteLight(ID id); - -//! возвращает имя света -SX_LIB_API char* SML_LigthsGetName(ID id); - -//! устанавливает имя света -SX_LIB_API void SML_LigthsSetName(ID id, const char *szName); - -//! отрисовка ограничивающего объема -SX_LIB_API void SML_LigthsRender(ID id, DWORD timeDelta); - -//! в color записывает цвет света -SX_LIB_API void SML_LigthsGetColor(ID id, float3 *pColor); - -//! устанавливает цвет света -SX_LIB_API void SML_LigthsSetColor(ID id, const float3 *pColor); - -//! получить в pos позицию света -SX_LIB_API void SML_LigthsGetPos( - ID id, //!< идентификатор света - float3 *pPos, //!< инициализированный вектор в который будет записана позиция - bool isReal = false //!< true - нужны реальные координаты, false - нужны углы, только для глобального света, во всех остальных случаях не имеет смысла - ); - -//! установить позицию свету -SX_LIB_API void SML_LigthsSetPos( - ID id, //!< идентификатор света - const float3 *pPos, //!< позиция в которую будет перемещен свет - bool isReal = false //!< true - установка реальных координат, false - установка углов, только для глобального света, во всех остальных случаях не имеет смысла - ); - -//! возвращает "значение силы света" для отправки в шейдер (максимальная компонента цвет * дистанция покрытия/#LIGHTS_LOCAL_MAX_DIST) -SX_LIB_API float SML_LigthsGetPower(ID id); - -//! возвращает дистанцию, на которую распространяется свет -SX_LIB_API float SML_LigthsGetDist(ID id); - -//! установка новой дистанции -SX_LIB_API void SML_LigthsSetDist( - ID id, //!< идентификатор света - float fDist, //!< новая дистанция(радиус для точечного и высота для направленного) - bool isCreate = true //!< нужно ли пересоздание объема? (если новая дистанция больше чем текущий ограничивающий объем то надо, в других случаях по усмотрению) - ); - -//! записывает в q ориентацию света -SX_LIB_API void SML_LigthsGetOrient(ID id, SMQuaternion *pQ); - -//! установка ориентации света -SX_LIB_API void SML_LigthsSetOrient(ID id, const SMQuaternion *pQ); - - -//! включен ли свет с идентификатором id -SX_LIB_API bool SML_LigthsGetEnable(ID id); - -//! установить всключен (true) или отключен (false) свет с идентификатором id -SX_LIB_API void SML_LigthsSetEnable(ID id, bool isEnable); - -//! возвращает идентификатор глобального источника света, если он есть, иначе -1 -SX_LIB_API ID SML_LigthsGetGlobal(); - -//! возвращает установлена ли общая тень от глобального источника (все ли в тени) -SX_LIB_API bool SML_LigthsGetCastGlobalShadow(); - -//! установить общую тень для всего от глобального источника (все в тень) -SX_LIB_API void SML_LigthsSetCastGlobalShadow(bool isShadowed); - -//----------------------------------------------------------------------------- - -/*! \name Управление видимостью - \note Отдельный просчет - считает индивидуально для света и тут же возвращает результат просчетов - \note Предварительный просчет - просчет для всего света (к примеру в другом потоке) -@{*/ - -//! виден ли свет в данном фрустуме (отдельный просчет) -SX_LIB_API bool SML_LigthsComVisibleForFrustum(ID id, const IFrustum *pFrustum); - -//! дистанция от viewpos до начала света (отдельный просчет) -SX_LIB_API float SML_LigthsComDistFor(ID id, const float3 *pViewPos); - -//! просчет видимости и расстояния от наблюдателя viewpos до начала света, для каждого света (предварительный просчет) -SX_LIB_API void SML_LigthsComVisibleFrustumDistFor(const IFrustum *pFrustum, const float3 *pViewPos); - - -//! виден ли свет в просчитанном фрустуме -SX_LIB_API bool SML_LigthsGetVisibleForFrustum(ID id); - -//! просчитанная дистанция от позиции наблюдателя до начала света -SX_LIB_API float SML_LigthsGetDistFor(ID id); - -//!@} - -//----------------------------------------------------------------------------- - -/*! \name Настройки для направленного света -@{*/ - -//! возвращает угол, актуально только для направленного и света -SX_LIB_API float SML_LigthsGetAngle(ID id); - -//! установить угол, актуально только для направленного и света -SX_LIB_API void SML_LigthsSetAngle(ID id, float fAngle); - -//! возвращает верхний радиус, актуально только для направленного и света -SX_LIB_API float SML_LigthsGetTopRadius(ID id); - -//! устанавливает верхний радиус, актуально только для направленного и света -SX_LIB_API void SML_LigthsSetTopRadius(ID id, float fTopRadius); - -//!@} - -//----------------------------------------------------------------------------- - -/*! \name Настройки для точечного света -@{*/ - -/*! установить "рисовать ли в указанную грань cubemap тени" - \warning Актуально только когда свет может отбрасывать тени - */ -SX_LIB_API void SML_LigthsSetCubeEdgeEnable( - ID id, //!< идентификатор света - int iEdge, //!< номер стороны/грани cubemap [0,5] - bool iEnable //!< true - рисовать, false - не рисовать - ); - -//! получить текущее значение "рисовать ли в указанную грань cubemap тени" -SX_LIB_API bool SML_LigthsGetCubeEdgeEnable( - ID id, //!< идентификатор света - int iEdge //!< номер стороны/грани cubemap [0,5] - ); - -//!@} - -//----------------------------------------------------------------------------- - -/*! \defgroup sxmtllight_light_shadow Управление тенями - \ingroup sxmtllight_light - \note Для генерации теней используется один render target full screen - \note Для сглаживания используется еще один аналогичный render target и первый render target. При сглаживании внутри меняется только счетчик, который меняет их местами - \note Так как используется всего один render target для генерации теней то есесно в текущий момент времени можно сгенерировать и сгладить тень только для одного света - \note Для теней от глобального света используется техника PSSM (Parallel-Split Shadow Mapping) на 3/4 сплита для объектов уровня (3 или 4 сплита можно настроить #SML_LigthsSet4Or3SplitsG) - \note Для теней от локального света используется техника Shadow Mapping в двух вариациях: - - для точечного света используется cubemap - - для направленного света - обычная техника Shadow Mapping -@{*/ - -//! отбрасывает ли свет тени -SX_LIB_API bool SML_LigthsGetShadowed(ID id); - -//! возвращает true в случае если установлено 4 сплита для PSSM, иначе (установлено 3 сплита) false -SX_LIB_API bool SML_LigthsGet4Or3SplitsG(ID id); - -//! установка количества сплитов (false - 3, true - 4) для PSSM -SX_LIB_API void SML_LigthsSet4Or3SplitsG(ID id, bool is4or3); - -/*! устанавливает шейдеры и передает им данные на основании типа материала, поддерживаются все типы MTL_TYPE_*/ -SX_LIB_API void SML_LigthsShadowSetShaderOfTypeMat(ID id, int typemat, const float4x4 *pWorld); - -/*! \name Управление обновлениями теней - \note Так как основная задумка это real-time рендер то для этого нужны упрощения, одним из таковых является обновление теней от света, которое может происходить не каждый кадр -@{*/ - -//! установка динамики обработки теней -SX_LIB_API void SML_LigthsSetTypeShadowed( - ID id, //!< идентификатор света - LTYPE_SHADOW type //!< значение из перечисления #LTYPE_SHADOW - ); - -//! возвращает тип динамики теней (одно из значений #LTYPE_SHADOW) -SX_LIB_API LTYPE_SHADOW SML_LigthsGetTypeShadowed(ID id); - -//! производит обработку данных затем возвращает разрешено ли обновлять тени, увеличивает внутрений счетчик, поэтому необходимо вызывать только когда надо -SX_LIB_API bool SML_LigthsCountUpdateUpdate( - ID id, //!< идентификатор света - const float3 *pViewPos, //!< позиция камеры для которой обновляем, на основании расстояния будет произведен расчет обновления - int iHow = -1 //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//! разрешено ли обновлять тени, в отличии от #SML_LigthsUpdateCountUpdate не увеличивает внутренний счетчик -SX_LIB_API bool SML_LigthsCountUpdateAllowed( - ID id, //!< идентификатор света - int iHow = -1 //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//! сбросить счетчик обновлений и обновлять до предела тени -SX_LIB_API void SML_LigthsCountUpdateNull(ID id); - -//!@} - - -/*! \name Управление циклами рендера в карты глубин - Для локального направленного света: - \code - SML_LigthsShadowRenderBegin(id); - //рендер того что должно отбросить тени - SML_LigthsShadowRenderEnd(id); - \endcode - Для глобального и точечного: - \code - SML_LigthsShadowRenderBegin(id); - SML_LigthsShadowRenderPre(id, cube); - //рендер того что должно отбросить тени - SML_LigthsShadowRenderPost(id, cube); - SML_LigthsShadowRenderEnd(id); - \endcode - Где cube для точечного это номер стороны cubemap [0-5] в которую будет осуществлен рендер, а для глобального это номер сплита. -@{*/ - -//! подготовительные процедуры -SX_LIB_API void SML_LigthsShadowRenderBegin(ID id); - -//! завершающие процедуры -SX_LIB_API void SML_LigthsShadowRenderEnd(ID id); - -//! подготовительные процедур перед рендером для сплита/стороны -SX_LIB_API void SML_LigthsShadowRenderPre( - ID id, //!< идентификатор света - int iCube //!< для точечного света - сторона cubemap [0-5] для глобального света номер сплита - ); - -//! завершающие процедур перед рендером для сплита/стороны -SX_LIB_API void SML_LigthsShadowRenderPost( - ID id, //!< идентификатор света - int iCube //!< для точечного света - сторона cubemap [0-5] для глобального света номер сплита - ); - -//!@} - -//! обнуление карты теней, необходимо вызывать перед генерацией теней посредством функции #SML_LigthsGenShadow -SX_LIB_API void SML_LigthsShadowNull(); - -//! генерация тени на основе уже отработанной информации о затенении, перед вызовов этой функции необходимо вызывать #SML_LigthsShadowNull -SX_LIB_API void SML_LigthsShadowGen(ID id); - -//! возвращает текстуру с тенями (если вызывались функции сглаживания) то вренутся сглаженная -SX_LIB_API IDirect3DTexture9* SML_LigthsGetShadow(); - -//! сглаживание текущей тени -SX_LIB_API void SML_LigthsShadowSoft( - bool isRandSam, //!< использовать ли смещение по случайному направлению - float fSize, //!< коэфициент увеличения размера пикселя для размытия - bool isFirst = false //!< впервые ли вызывается размытие для текущей тени, каждый раз когда тень еще не сглажена, но сгенерирована, нужно указывать false - ); - -//! возвращает указатель фрустума света -SX_LIB_API IFrustum* SML_LigthsGetFrustum( - ID id, //!< идентификатор света - int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//! обновление фрустума глобального света -SX_LIB_API void SML_LigthsUpdateGFrustums( - ID id, //!< идентификатор света - int iSplit, //!< номер сплита - const float3 *pPos, //!< позиция наблюдателя - const float3 *pDir //!< направление взгляда наблюдателя - ); - -/*! \name Управление настройками для генерации глубины/тени -@{*/ - -//! получить текущее смещение (bias) при генерации глубины -SX_LIB_API float SML_LigthsGetShadowBias(ID id); - -//! установить текущее смещение (bias) при генерации глубины -SX_LIB_API void SML_LigthsSetShadowBias(ID id, float fBias); - - -//! установить размерность размытия (в пикселя) при геренации тени -SX_LIB_API void SML_LigthsSetShadowBlurPixel(ID id, float fBlurPixel); - -//! получить текущее значение размерности (в пикселях) при генерации тени -SX_LIB_API float SML_LigthsGetShadowBlurPixel(ID id); - - -//! установить значение ближней плоскостью отсечения для теней (локальный свет) -SX_LIB_API void SML_LigthsSetShadowLocalNear(ID id, float fNear); - -//! получить текущее значение ближней плоскостью отсечения для теней (локальный свет) -SX_LIB_API float SML_LigthsGetShadowLocalNear(ID id); - -/*! установка дальней плоскостью отсечения для теней (локальный свет) - \note Иногда возникают артефакты и если отрегулировать это значение то все становится на свои места, тесты показали что в основном при ошибках, увеличение этого значения решало проблемы -*/ -SX_LIB_API void SML_LigthsSetShadowLocalFar( - ID id, //!< идентификатор света - float fFar //!< значение дальней плоскости отсечения (дальность видимости теней), обычно это значение = дальность света - ); - -//! возвращает значение дальней плоскости отсечения (дальности видимости теней) -SX_LIB_API float SML_LigthsGetShadowLocalFar(ID id); - -//!@} - -//----------------------------------------------------------------------------- - -/*! \name Управление массивами обработки данных для рендера (к примеру от геометрии, растительности и прочего) - Cделано для того чтобы отделить просчеты видимости (если они нужны) от рендера. - К примеру можно рассчитать видимости в одном потоке а рисовать в основном. -@{ -*/ - -//! возвращает идентификатор в случае успеха, иначе <0 -SX_LIB_API ID SML_LigthsGetIDArr( - ID id, //!< идентификатор света - ID idOwner, //!< идентификатор объекта/системы вообще того что выдало идентификатор массива - int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//! установить идентификатор -SX_LIB_API void SML_LigthsSetIDArr( - ID id, //!< идентификатор света - ID idOwner, //!< идентификатор объекта/системы вообще того что выдало идентификатор массива - int iHow, //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ID idArr //!< номер массива обработки от объекта который надо будет обрабатывать на видимость - ); - -//!@} - -//!@} sxmtllight_light_shadow - -//! обработка tone mapping -SX_LIB_API void SML_LigthsToneMappingCom( - DWORD timeDelta, //!< время рендера кадра в млсек - float fFactorAdapted = 0.3 //!< на сколько быстро "глаз" привыкнет к освещению (0,1] (медленно, быстро] - ); - -/*! \name Функции обработки удаленного света - При удалении света он помещается в специальный массив удаленных объектов, -это связано с тем что свет может содержать в себе данные которые требуют очистки памяти вне данной реализации, -к примеру идентификаторы массивов просчетов видимости. \n - Поэтому необходимо вручную удалять (уже после удаленяи функцией #SML_LigthsDeleteLight) удаленные объекты света. - \note Доступ к элементам массива удаленных объектов света осуществляется посредством порядкового номера в массиве (ключа key), то есть можно пройтись по массиву циклом. -@{*/ - -//! возвращает количество удаленных объектов света которые требуют удаления -SX_LIB_API int SML_LigthsDelGetCount(); - -//! возвращает тип удаленного объекта света, значения из #LightsTypeLight -SX_LIB_API LTYPE_LIGHT SML_LigthsDelGetType(ID key); - -//! удаляет (окончательно) удаленный объект света -SX_LIB_API void SML_LigthsDelDel(ID key); - -//! возвращает идентификатор, если был передан, иначе <0 -SX_LIB_API ID SML_LigthsDelGetIDArr( - ID key, //!< порядковый номер объекта света в массиве удаленного света - ID idOwner, //!< идентификатор того что выдало идентификатор массива - int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//!@} - -//!@} sxmtllight_light - -//############################################################################# - -/*! \defgroup sxmtllight_ds Render targets для deferred shading - \ingroup sxmtllight -@{*/ - -//! типы render targets -enum DS_RT -{ - //! цвет rgba8 - DS_RT_COLOR = 0, - - //! нормали (включая микрорельеф) rfb10a2 - DS_RT_NORMAL, - - //! параметры освещения rgba8 - DS_RT_PARAM, - - //! глубина r16f, непрозрачные материалы - DS_RT_DEPTH, - - //! глубина r16f, непрозрачные материалы - DS_RT_DEPTH0, - - //! глубина r16f, непрозрачные и полупрозрачные пиксели, однако прозрачные (если есть) будут перекрывать непрозрачные, и в этом случае их глубина будет 1 то есть максимальной(для идентификации) - DS_RT_DEPTH1, - - - //! эмбиент цвет (цвет света rgb) и диффузное освещение (a) rgba16f - DS_RT_AMBIENTDIFF, - - //! блики r16f - DS_RT_SPECULAR, - - //! освещенная сцена rgba16 - DS_RT_SCENELIGHT, - - //! освещенная сцена rgba16 - DS_RT_SCENELIGHT2, - - //! текущий rt адаптации глаза к освещению r16f - DS_RT_ADAPTEDLUM -}; - -//! id render target по его типу -SX_LIB_API ID SML_DSGetRT_ID(DS_RT type); - -//! текстура render target по его типу -SX_LIB_API IDirect3DTexture9* SML_DSGetRT(DS_RT type); - -//!@} sxmtllight_ds - -//############################################################################# - -/*! \defgroup sxmtllight_mtl Система материалов - \ingroup sxmtllight -@{*/ - -/*! максимальная длина имени директории материала */ -#define MTL_MAX_SIZE_DIR SXGC_LOADTEX_MAX_SIZE_DIR - -/*! максимальная длина имени материала (без директории) */ -#define MTL_MAX_SIZE_NAME SXGC_LOADTEX_MAX_SIZE_NAME - -/*! максимальное количество обновлений статических отражений, в первый момент рендера */ -#define MTL_REF_UPDATE_MAX_COUNT_FOR_STATIC 3 - -/*! \name Дистанции при которых будут сниженно или повышено количество отрисовок для отражений -меньше #MTL_REF_UPDATE_L0_DIST - обновление будет каждый кадр -больше #MTL_REF_UPDATE_L2_DIST - обновления не будет -@{*/ - -#define MTL_REF_UPDATE_L0_DIST 10 -#define MTL_REF_UPDATE_L1_DIST 30 -#define MTL_REF_UPDATE_L2_DIST 70 - -//!@} - -/*! \name Параметры альфа теста - В данной реалзиации 2 вида альфа теста, принудительный (#SML_MtlSetForceblyAlphaTest) и назначаемый непосредственно материалом - \note функция альфа теста D3DCMP_GREATEREQUAL -@{*/ - -/*! значение свободного альфа теста (назначаемого материалом) */ -#define MTL_ALPHATEST_FREE_VALUE 64 - -/*! значение принудительного альфа теста */ -#define MTL_ALPHATEST_FORCEBLY_VALUE 8 - -//!@} - -/*! \name Значения параметров освещения по умолчанию - Данные значения по умолчанию будут применены к материалами которые не удалось загрузить, либо к стандартным материалам -@{*/ - -//! занчение шероховатости по умолчанию -#define MTL_LIGHTING_DEFAULT_ROUGHNESS 250.f/255.f - -//! значение f0 (отражательной способности поверхности) по умолчанию -#define MTL_LIGHTING_DEFAULT_F0 2.f/255.f - -//! значение thickness (толщина - на сколько будет использована диффузная составляющая, для твердых поверхностей - 1, для листьев деревьев и травы <1) по умолчанию -#define MTL_LIGHTING_DEFAULT_THICKNESS 255.f/255.f - -//!@} - -/*! \name Параметры отражений -@{*/ - -/*! размер текстур с отражениями */ -#define MTL_REF_TEX_SIZE 512 - -/*! ближняя плоскость отсечения */ -#define MTl_REF_PROJ_NEAR 0.25 - -/*! дальняя плоскость отсечения, или дистанция на которую будет рендер всего в текстуру отражений */ -#define MTl_REF_PROJ_FAR 100 - -//!@} - -/*! \name Виртуальные директории - \warning Имя виртуальной директории должно быть единичным символом (сделано для простоты сравнения), -и как следствие нежелательно использоавть реальную директорию с таким именем для текстур либо материалов, -и реальные директории не должны начинаться с данных символов -@{*/ - -//! имя виртуальной директории по умолчанию для "ручных" текстур с параметрами освещения -#define MTL_VIRTUAL_DIR_HAND_MTL '0' - -//! имя виртуальной директории по умолчанию для стандартных (встроенных) материалов -#define MTL_VIRTUAL_DIR_STD_MTL "mtrldef" - -//!@} - -/*! \name Текстурные регистры -Распределение регистров между текстурами которые будут отправляться для формирования данных -@{*/ - -/*!< основная текстура */ -#define MTL_TEX_R_MAIN 0 - -/*!< маска */ -#define MTL_TEX_R_MASK 1 - -/*! стартовый регистр для детальных текстур - \warning 4 следующих (включая указанный) будует заполнены детальными текстурами, поэтому никакие другие текстуры в [MTL_TEX_R_DETAIL, MTL_TEX_R_DETAIL+3] не должны отправляться - \note Текстуры для каждого канала будут отправляться последовательно: r, g, b, a - MTL_TEX_R_DETAIL, MTL_TEX_R_DETAIL + 1, MTL_TEX_R_DETAIL + 2, MTL_TEX_R_DETAIL + 3 -*/ -#define MTL_TEX_R_DETAIL 2 - -/*! стартовый регистр для микрорельефных текстур -\warning 4 следующих (включая указанный) будует заполнены микрорельефными текстурами, поэтому никакие другие текстуры в [MTL_TEX_R_MICRO, MTL_TEX_R_MICRO+3] не должны отправляться -\note Текстуры для каждого канала будут отправляться последовательно: r, g, b, a - MTL_TEX_R_MICRO, MTL_TEX_R_MICRO + 1, MTL_TEX_R_MICRO + 2, MTL_TEX_R_MICRO + 3 -*/ -#define MTL_TEX_R_MICRO 6 - - -/*! текстура с параметрами освещения */ -#define MTL_TEX_R_PARAM_LIGHT 10 - -/*! текстура с отражениями */ -#define MTL_TEX_R_REFLECTION 12 - -/*! текстура с преломлениями */ -#define MTL_TEX_R_REFRACTION 13 - -/*! текстура с текущей глубиной */ -#define MTL_TEX_R_CURR_DEPTH 14 - -//!@} - -//! типы отражений -enum MTLTYPE_REFLECT -{ - //! нет отражения - MTLTYPE_REFLECT_NONE, - - //! плоское - MTLTYPE_REFLECT_PLANE, - - //! объемное динамическое - MTLTYPE_REFLECT_CUBE_DYNAMIC, - - //! объемное статическое, обработка идет первые несколько кадров, затем не обновляется - MTLTYPE_REFLECT_CUBE_STATIC -}; - -//! типы прозрачности -enum MTLTYPE_TRANSPARENCY -{ - //! нет прозрачности - MTLTYPE_TRANSPARENCY_NONE, - - //! освещаяемая прозрачность - MTLTYPE_TRANSPARENCY_ALPHA_LIGHT, - - //! неосвещаяемая прозрачность - MTLTYPE_TRANSPARENCY_ALPHA_UNLIT, -}; - -/*! \name Возможные слои -@{*/ - -//! непрозрачные неосвещаемые -#define MTLTYPE_LAYER_OPAQUE_UNLIT 0.0f - -//! прозрачные неосвещаемые -#define MTLTYPE_LAYER_TRANSPARENT_UNLIT 0.66f - -//! непрозрачные освещаемые -#define MTLTYPE_LAYER_OPAQUE_LIGHT 0.33f - -//! прозрачные освещаемые -#define MTLTYPE_LAYER_TRANSPARENT_LIGHT 1.0f - -//!@} - -//! тип модели материала -enum MTLTYPE_MODEL -{ - //! статическая геометрия - MTLTYPE_MODEL_STATIC = 0, - - //! растительность трава - MTLTYPE_MODEL_GRASS, - - //! растительность дерево - MTLTYPE_MODEL_TREE, - - //! анимационная модель - MTLTYPE_MODEL_SKIN, - - //! значение по умолчанию - MTLTYPE_MODEL_DEFAULT = MTLTYPE_MODEL_STATIC -}; - -//! физический тип материала -enum MTLTYPE_PHYSIC -{ - MTLTYPE_PHYSIC_CONCRETE = 0, //!< бетон - - //! значение по умолчанию - MTLTYPE_PHYSIC_DEFAULT = MTLTYPE_PHYSIC_CONCRETE, - - //! металл - MTLTYPE_PHYSIC_METAL, - - //! стекло - MTLTYPE_PHYSIC_GLASS, - - //! пластик - MTLTYPE_PHYSIC_PLASTIC, - - //! дерево - MTLTYPE_PHYSIC_TREE, - - //! плоть - MTLTYPE_PHYSIC_FLESH, - - //! земля/песок - MTLTYPE_PHYSIC_GROUD_SAND, - - //! вода - MTLTYPE_PHYSIC_WATER, - - //! листва/трава - MTLTYPE_PHYSIC_LEAF_GRASS, - - //! количество типов - MPT_COUNT -}; - -//! данные отправляемые в шейдеры -enum MTL_SHADERSTD -{ - //! мировая матрица (трансформации модели), world - MTL_SHADERSTD_MATRIX_WORLD = 0, - - //! матрица вида, view - MTL_SHADERSTD_MATRIX_VIEW, - - //! матрица проекции, projection - MTL_SHADERSTD_MATRIX_PROJECTION, - - //! world * view - MTL_SHADERSTD_MATRIX_WORLDVIEW, - - //! world * view * projection - MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ, - - //! позиция камеры/наблюдателя - MTL_SHADERSTD_CAMPOS, - - //! данные о времени float2(CountTimeRender,TimeDelta) - MTL_SHADERSTD_TIMEDELTA, - - //! размеры окна рендера - MTL_SHADERSTD_WINSIZE, - - //! пользовательские данные (float4) - MTL_SHADERSTD_USERDATA -}; - -/*! \name Загрузка/сохранение - \note Файл загрузки/сохранения представлен простым конфигурационным файлом (ini) который можно обрабатывать посредством #ISXLConfig - \todo Расписать организацию конфигурационного файла загрузки/сохранения для материала -@{*/ - -/*! загрузка материала, возвращает уникальный идентификатора материала, - \note все материалы оборачиваются в специальную структуру, поэтому дубликатов среди идентификаторов материалов нет - \note любой повторно загружаемый материал не загружается, а лишь дублирует обертку, со ссылкой на внутренности оберкти - */ -SX_LIB_API ID SML_MtlLoad( - const char *szName, //!< имя_материала.расширение - MTLTYPE_MODEL mtl_type = MTLTYPE_MODEL_STATIC //!< тип модели материала на случай если материал не будет загружен/найден - ); - -//! перезагрузка материала -SX_LIB_API void SML_MtlReloadMaterial( - ID id, //!< идентификатор материала - const char *szName = 0 //!< на случай замены существующего материала другим - ); - -/*! сохранить материал по id - \note Сохранение происходит по отноительному пути в директория/директория_имяфайла.mtl -*/ -SX_LIB_API void SML_MtlSave(ID id); - -//!@} - -/*! очитска, удаляет все загруженные материалы (но место в массиве под них остается), все стандартные остаются - \warning Отражения не удаляются а помещаются в очередь удаления, так как могут сожеражть в себе идентификаторы, которые необходимы очистить, -для полной очистки необходимо вызывать функцию #SML_MtlDelRefClear. Однако во избежания утечек памяти необходимо очистить идентификаторы, для их получения вызыва функцию #SML_MtlDelRefGetIDArr -*/ -SX_LIB_API void SML_MtlClear( - bool isClearRefDel //!< очищать ли очередь удаления отражений, на тот случай если идентификаторы в отражениях больше не действительны - ); - -//! возвращает общее количество материалов -SX_LIB_API long SML_MtlGetCount(); - -//! возвращает тип модели материала по id -SX_LIB_API MTLTYPE_MODEL SML_MtlGetTypeModel(ID id); - -/*! установка типа модели материала по id - \warning меняется только внутренний флаг (определение)!!! все остальное для данного типа надо загружать вручную, сделано для больших возможностей построения материалов -*/ -SX_LIB_API void SML_MtlSetTypeModel(ID id, MTLTYPE_MODEL type_model); - -//! установка параметров материала по id, вызывается перед DIP -SX_LIB_API void SML_MtlRender( - ID id, //!< идентификатор материала - const float4x4 *pWorld //!< указатель на мировую матрицу модели, либо 0 - тогда будет принята единичная матрица - ); - -//! стандартная отрисовка материала, используются стандартные шейдеры, нужно для теней, отражений и прочего -SX_LIB_API void SML_MtlRenderStd( - MTLTYPE_MODEL type, //!< тип материала из MtlTypeModel - const float4x4 *pWorld, //!< мировая матрица трансформации, либо 0 и будет применена единичная матрица - ID idSlot, //!< текстурный слот в который установить текстуру - ID idMtl //!< идентификатор материала из которого будет браться текстура - ); - -//! установка параметров материала для рендера источника света -SX_LIB_API void SML_MtlRenderLight( - const float4_t *pColor, //!< rgb - цвет, w зарезервирован - const float4x4 *pWorld //!< аналогично #SML_MtlRender - ); - -//! установить текстуру из материала id в текстурный слот slot -SX_LIB_API void SML_MtlSetMainTexture(ID idSlot, ID id); - - -//! установка физического типа материала -SX_LIB_API void SML_MtlSetPhysicMaterial(ID id, MTLTYPE_PHYSIC type); - -//! возвращает текущий тип физического материала -SX_LIB_API MTLTYPE_PHYSIC SML_MtlGetPhysicMaterial(ID id); - -//! возвращает id стандартного материала для определенной модели материалов указанной в #MtlTypeModel -SX_LIB_API ID SML_MtlGetStdMtl(MTLTYPE_MODEL type_model); - -/*! \name Управление полупрозрачными поверхностями -Каждый выводимый пиксель помечается номером поверхности к которой он относится - - 0 - пусто - - 1 - непрозрачная геометрия - - все что больше 1 значит полупрозрачная геометрия - \note Если инкремент установлен то отрисовка каждого материала будет инкрементировать внутренний счетчик, присваивая каждому пикселю поверхности идентификатор поверхности. - \note На данный момент максимальное значение полупрозрачных поверхностей может быть только 255 (8 бит) -@{*/ - -/*! установка инкремента идентификатора поверхностей - \note К примеру для диференциации (разделения) пикселей при смешивании всех слоев изображения, -без разделения по принадлжености к определнной поверхности будет трудно/невозможно (пока выхода нет) корректно смешать все слои -*/ -SX_LIB_API void SML_MtlSetIsIncrCountSurf(bool bf); - -//! установлен ли инкремент поверхностей -SX_LIB_API bool SML_MtlGetIsIncrCountSurf(); - -//! обнуление идентификатора отрисованных поверхностей (к примеру при новом кадре) -SX_LIB_API void SML_MtlNullingCurrCountSurf(); - -//! текущее количество отрисованных полупрозрачных поверхностей -SX_LIB_API int SML_MtlGetCurrCountSurf(); - -//! установить текущее количество отрисованных полупрозрачных поверхностей -SX_LIB_API void SML_MtlSetCurrCountSurf(int iCount); - -/*! принудительное включение альфа теста (isat - true - включить, false - выключить) при устновке параметров материала, -к примеру для рендера полупрозрачных поверхностей, чтобы отсечь (условно) полностью прозрачные пиксели -*/ -SX_LIB_API void SML_MtlSetForceblyAlphaTest(bool isEnable); - -//! включен ли принудительный альфа тест -SX_LIB_API bool SML_MtlGetForceblyAlphaTest(); - -//!@} - -/*! \defgroup sxmtllight_mtl_reflect Отражения - \ingroup sxmtllight_mtl - \note Поддерживается 2 вида отражений: - - плоские - - объемные/кубические -@{*/ -//{{ - -//! записать в отражения идентификатор (idArr) для определнной стороны куба/сплита (iCube), соотнести его с идентификатором сущности (idOwner) -SX_LIB_API void SML_MtlRefSetIDArr( - ID id, //!< идентификатор материала - ID idOwner, //!< идентификатор сущности для которой записываем (геометрия, растительность и прочее) - int iCube, //!< условно - сторона куба/сплита для которой записываем - ID idArr //!< идентификатор который надо записать - ); - -//! возвращает идентификатор который был записан для сущности (idOwner) для стороны куба/сплита (iCube), если вообще записывался, если не записывался то <0 -SX_LIB_API ID SML_MtlRefGetIDArr( - ID id, //!< идентификатор материала - ID idOwner, //!< идентификатор сущности для которой было записывано (геометрия, растительность и прочее) - int iCube //!< условно - сторона куба/сплита для которой было записывано - ); - -/*! \name Управление удаленными отражениями -@{*/ - -//! возвращает количество удаленных материалов с отражениями -SX_LIB_API int SML_MtlDelRefGetCount(); - -//! возвращает идентификатор который был записан для сущности (inid) для стороны куба/сплита (cube) -SX_LIB_API ID SML_MtlDelRefGetIDArr( - ID idKey, //!< порядковый номер удаленного материала с отражением - ID idOwner, //!< идентификатор сущности для которой было записано (геометрия, растительность и прочее) - int iCube //!< условно - сторона куба/сплита для которой было записывано - ); - -//! очистка массива удаленных материалов с отражениями -SX_LIB_API void SML_MtlDelRefClear(); - -//!@} - -//! обработка статистики рендера для текущего матриала с отражением -SX_LIB_API bool SML_MtlRefUpdateCountUpdate( - ID id, //!< идентификатора материала - const float3_t *pViewPos //!< позиция наблюдателя, viewpos == 0 вернет false - ); - -/*! обнуление статистикки рендера для данного материала с отражением, -полезно в случаях каких-либо изменений, чтобы эти изменения были видны и в отражениях (актуально для статических отражений) -*/ -SX_LIB_API void SML_MtlRefNullingCountUpdate(ID id); - -//! установка экстремумов материала -SX_LIB_API void SML_MtlRefSetMinMax(ID id, const float3_t *pMin, const float3_t *pMax); - -//! возвращает фрустум отражения, cube - сторона куба -SX_LIB_API const IFrustum* SML_MtlRefGetfrustum( - ID id, //!< идентификатора материала - int iCube //!< сторона куба, если отражение плоское то необходимо указать в cube передать 0, иначе вернет NULL - ); - -SX_LIB_API bool SML_MtlRefIsAllowedRender(ID id); //!< разрешен ли рендер отражений для данного материала в текущий момент - -/*! \name Рендер плоского отражения - \note Перед началом рендера плоских отражений необходимо в регистры матриц в #G_RI_MATRIX_VIEW поместить матрицу вида наблюдателя - \note Порядок рендера: - \code - SML_MtlRefPreRenderPlane(id, plane); - //код рендера всего того что необходимо поместить в текстуру отражений - SML_MtlRefPostRenderPlane(id); - \endcode -@{*/ - -//! первоначальные настройки данных для генерации отражения -SX_LIB_API void SML_MtlRefPreRenderPlane( - ID id, //!< идентификатор материала - D3DXPLANE *pPlane //!< плоскость относительно которой будет считаться отражение - ); - -//! завершающие операции -SX_LIB_API void SML_MtlRefPostRenderPlane(ID id); - -//! возвращает текстуру с плоским отражением (если оно есть, иначе 0) -SX_LIB_API IDirect3DTexture9* SML_MtlRefGetTexPlane(ID id); - -//!@} - -/*! \name Рендер объемного (кубического) отражения - \note Порядок рендера: - \code - SML_MtlRefCubeBeginRender(id, center); - SML_MtlRefCubePreRender(id, cube, world); - //код рендера всего того что необходимо поместить в текстуру отражений - SML_MtlRefCubePostRender(id, cube); - SML_MtlRefCubeEndRender(id, viewpos); - \endcode -@{*/ - -//! установка общих настроек -SX_LIB_API void SML_MtlRefCubeBeginRender( - ID id, //!< идентификатор материала - const float3_t *pCenter //!< центр (позиция) подгруппы модели - откуда будет рендер отражений - ); - -//! установка частных настроек для стороны куба (cube) -SX_LIB_API void SML_MtlRefCubePreRender( - ID id, //!< идентификатор материала - int iCube, //!< сторона куба [0,5] - const float4x4 *pWorld //!< мировая матрица модели - ); - -//! завершающие частные моменты для стороны куба -SX_LIB_API void SML_MtlRefCubePostRender(ID id, int iCube); - -/*! завершающие общие моменты - \note если viewpos == 0 обновления статисктики рендера для текущего материала с отражением не произойдет, -и дабы рационально обрабатывать и статические и динамические отражения необходимо до следующего рендера отражений вызвать SML_MtlRefUpdateCountUpdate -*/ -SX_LIB_API void SML_MtlRefCubeEndRender( - ID id, //!< идентификатор материала - const float3_t *pViewPos //!< позиция наблюдателя, необходимо для обработки разрешения на следующий рендер - ); - -//! возвращает cube текстуру отражением (если оно есть, иначе 0) -SX_LIB_API IDirect3DCubeTexture9* SML_MtlRefCubeGetTex(ID id); - -//!@} - -//!@} sxmtllight_mtl_reflect - - -/*! \defgroup sxmtllight_mtl_propslayer Cвойства поверхности - \ingroup sxmtllight_mtl -@{*/ - -//! установка основной текстуры (загрузка текстуры по имени) -SX_LIB_API void SML_MtlSetTexture(ID id, const char *szPathTex); - -//! в name записывает имя текстуры -SX_LIB_API void SML_MtlGetTexture(ID id, char *szName); - -//! возвращает id текстуры материала -SX_LIB_API ID SML_MtlGetTextureID(ID id); - - -/*! \name Шейдеры для рендера материала - \warning В текущей версии все шейдеры загружаются в версии 3.0 и требуют в качестве старта указывать функцию main - \warning Рекомендуется устанавливать и вершинный и пиксельный шейдеры, так как во врем тестов одно из устройств требовало наличия обоих шейдеров либо отсутствия обоих - \note В аргументах path_vs/path_ps указывается только имя шейдера с расширением, есесно возвращается тоже самое -@{*/ - -//! установка вершинного шейдера -SX_LIB_API void SML_MtlSetVS(ID id, const char *szPathVS); - -//! в name записывает имя текущего вершинного шейдера -SX_LIB_API void SML_MtlGetVS(ID id, char *szName); - -//! установка пиксельного шейдера -SX_LIB_API void SML_MtlSetPS(ID id, const char *szPathPS); - -//! в name записывает имя текущего пикельного шейдера -SX_LIB_API void SML_MtlGetPS(ID id, char *szName); - -//!@} - -//! возвращает коэффициент пробиваемости [0, ], чем больше тем сложнее пробить -SX_LIB_API float SML_MtlGetDurability(ID id); - -//! устанавливает коэффициент пробиваемости [0, ], чем больше тем сложнее пробить -SX_LIB_API void SML_MtlSetDurability(ID id, float fDurability); - - -//! возвращает шанс пробиваемости [0 - пуля летит насквозь, 1 - пуля ударяется] -SX_LIB_API float SML_MtlGetHitChance(ID id); - -//! устанавливает шанс пробиваемости [0 - пуля летит насквозь, 1 - пуля ударяется] -SX_LIB_API void SML_MtlSetHitChance(ID id, float fHitChance); - - -//! возвращает плотность материала кг/м3 -SX_LIB_API float SML_MtlGetDensity(ID id); - -//! устанавливает плотность материала кг/м3 -SX_LIB_API void SML_MtlSetDensity(ID id, float fDensity); - - -//! используется ли альфа тест для материала -SX_LIB_API bool SML_MtlGetUsingAlphaTest(ID id); - -//! установка использования альфа теста -SX_LIB_API void SML_MtlSetUsingAlphaTest(ID id, bool isUsing); - -/*! освещение материала id - \note если материал не освещается то будет выведен в цвете накладываемым материалом -*/ -SX_LIB_API void SML_MtlSetLighting(ID id, bool isLighting); - -//! освещается ли материал -SX_LIB_API bool SML_MtlGetLighting(ID id); - -/*! \name Параметры освещения. - \note Для более точной/тонкой настройки освещения материала рекомендуется использовать текстуру с параметрами освещения -(к прмиеру когда в одной поверхности разные материалы, к примеру дерево, метал и камень, то в текстуре можно указать параметры освещения для каждого пикселя), -однако если текстуры нет то будут использованы установленные парметры освещения для всей поверхности -@{*/ - -//! установка использования текстуры с параметрами освещения -SX_LIB_API void SML_MtlSetIsTextureLighting(ID id, bool isTexLighting); - -//! используется ли текстура с параметрами для освещения -SX_LIB_API bool SML_MtlGetIsTextureLighting(ID id); - - -//! загрузка текстуры с парамтерами освещения -SX_LIB_API void SML_MtlSetTextureLighting(ID id, const char *szPathTex); - -//! в path_tex записывает имя текстуры с параметрами освещения -SX_LIB_API void SML_MtlGetTextureLighting(ID id, char *szPathTex); - - -//! установка шероховатости (0-1) -SX_LIB_API void SML_MtlSetRoughness(ID id, float fRoughness); - -//! возвращает текущее значение шероховатости поверхности -SX_LIB_API float SML_MtlGetRoughness(ID id); - - -//! установка просвечиваемости (толщины для графики (0, 1)), 0 - не принимает затенение, 1 - полностью принимает затенение -SX_LIB_API void SML_MtlSetThickness(ID id, float fThickness); - -//! возвращает просвечиваемости (толщины для графики (0, 1)), 0 - не принимает затенение, 1 - полностью принимает затенение -SX_LIB_API float SML_MtlGetThickness(ID id); - -//! установка отражательной способности поверхности (0-1) -SX_LIB_API void SML_MtlSetF0(ID id, float fF0); - -//! возвращает текущее значение отражательной способности поверхности -SX_LIB_API float SML_MtlGetF0(ID id); - -//!@} - -/*! \name Полупрозрачность, типы из #MtlTypeTransparency -Под полупрозрачными материалами следует понимать такие материалы, прозрачность которых в среднем находится в пределах 0.5 и минимальный процент полупрозрачного периметра 50% -@{*/ - -//! установка типа полупрозрачности -SX_LIB_API void SML_MtlSetTypeTransparency(ID id, MTLTYPE_TRANSPARENCY type); - -//! возвращает текущий тип полупрозрачности для материала -SX_LIB_API MTLTYPE_TRANSPARENCY SML_MtlGetTypeTransparency(ID id); - -//!@} - -/*! \name Отражения окружения, типы из #MtlTypeReflect -@{*/ - -//! установка типа отражений -SX_LIB_API void SML_MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type); - -//! возвращает текущий тип отражений для материала -SX_LIB_API MTLTYPE_REFLECT SML_MtlGetTypeReflection(ID id); - -//!@} - -/*! \name Детальность и микрорельеф -Поверхность может содержать до 4 детальных текстур и до 4 текстур с микрорельефом. -Данные для определения наложения текстур (детальных и микрорельефных) указываются в маске - -на каждый канал текстуры маски по одной детальной и микрорельефной текстуре, -то есть канал маски определет связанные между собой и детальную и микрорельефную текстуры - \note В аргументах channel - RGBA - 0,1,2,3 -@{*/ - -//! загрузка маски наложения -SX_LIB_API void SML_MtlSetMaskTex(ID id, const char *szPathTex); - -//! в path_tex записывает текущее имя маски наложения -SX_LIB_API void SML_MtlGetMaskTex(ID id, char *szPathTex); - -//! загрузка текстуры микрорельефа, на каждый канал -SX_LIB_API void SML_MtlSetMRTex( - ID id, //!< идентификатор материала - int iChannel, //!< номер канала RGBA - 0,1,2,3 - const char *szPathTex //!< имя текстуры с расширением - ); - -//! в path_tex запишет текущее имя текстуры микрорельефа для канала channel -SX_LIB_API void SML_MtlGetMRTex(ID id, int iChannel, char *szPathTex); - -//! загрузка детальной текстуры, на каждый канал -SX_LIB_API void SML_MtlSetDTex( - ID id, //!< идентификатор материала - int iChannel, //!< номер канала RGBA - 0,1,2,3 - const char *szPathTex //!< имя текстуры с расширением - ); - -//! в path_tex запишет текущее имя детальной текстуры для канала channel -SX_LIB_API void SML_MtlGetDTex(ID id, int iChannel, char *szPathTex); - -//!@} - -/*! \name Стандартные параметры для отправки в шейдер (в вершинный и пиксельный раздельно), данные из #MtlTransShaderStd -@{*/ - -//! отправка стадартных данных в вершинный шейдер -SX_LIB_API void SML_MtlSetStdVS( - ID id, //!< идентификатор материала - MTL_SHADERSTD type, //!< тип значения которое нужно отправить, одно из значений #MtlTransShaderStd - bool isSend //!< true - отправлять, false - не отправлять - ); - -//! установлена ли отпрвка значения type в вершинный шейдер -SX_LIB_API bool SML_MtlGetStdVS(ID id, MTL_SHADERSTD type); - -//! отправка стадартных данных в пиксельный шейдер -SX_LIB_API void SML_MtlSetStdPS( - ID id, //!< идентификатор материала - MTL_SHADERSTD type, //!< тип значения которое нужно отправить, одно из значений #MtlTransShaderStd - bool isSend //!< true - отправлять, false - не отправлять - ); - -//! установлена ли отпрвка значения type в пиксельный шейдер -SX_LIB_API bool SML_MtlGetStdPS(ID id, MTL_SHADERSTD type); - -//!@} - -/*! \name Дополнительные пользовательские данные в виде float4 (предел [0-1] для стандарта, иное вне стандарта, но допустимо) - \note Данные для вершинного и пиксельного шейдера раздельны. Отправляется float4. -Однако данные и из пиксельного могут быть отправленны в вершинный и наоборот. -В итоге в шейдере может быть 2 float4 пользовательских вектора с данными. -Но если вектор определен для пиксельного то он все-равно будет отправлен в пиксельный шейдер, даже если и придназначалася для вершинного. - \note В аргументах component - xyzw - 0,1,2,3 -@{*/ - -//! установка значения компоненты вектора для вершинного шейдера -SX_LIB_API void SML_MtlSetUserDataVS( - ID id, //!< идентификатор материала - int iComponent, //!< компонента вектора xyzw - 0,1,2,3 - float fValue //!< значение компоненты - ); - -//! возвращает значение компоненты вектора, который отправляется в вершинный шейдер -SX_LIB_API float SML_MtlGetUserDataVS(ID id, int iComponent); - -//! установка отправки float4 вектора, предназначенного для вершинного шейдера, в пиксельный шейдер -SX_LIB_API void SML_MtlSetUserDataVS_InPS(ID id, bool isSendPs); - -//! отправляется ли float4 вектор, предназначенный для вершинного шейдера, в пиксельный шейдер -SX_LIB_API bool SML_MtlGetUserDataVS_InPS(ID id); - - -//! установка значения компоненты вектора для пиксельного шейдера -SX_LIB_API void SML_MtlSetUserDataPS( - ID id, //!< идентификатор материала - int iComponent, //!< компонента вектора xyzw - 0,1,2,3 - float fValue //!< значение компоненты - ); - -//! возвращает значение компоненты вектора, который отправляется в пиксельный шейдер -SX_LIB_API float SML_MtlGetUserDataPS(ID id, int iComponent); - -//! установка отправки float4 вектора, предназначенного для пиксельного шейдера, в вершинный шейдер -SX_LIB_API void SML_MtlSetUserDataPS_InVS(ID id, bool isSendVs); - -//! отправляется ли float4 вектор, предназначенный для пиксельного шейдера, в вершинный шейдер -SX_LIB_API bool SML_MtlGetUserDataPS_InVS(ID id); - -//!@} - -//!@} sxmtllight_mtl_propslayer - -//!@} sxmtllight_mtl - -#endif - -//!@} sxmtllight diff --git a/source/mtllight/sxmtllight.cpp b/source/mtllight/sxmtllight.cpp deleted file mode 100644 index 3c6f545aad5c8d345a9b01f0cc91f12a3206cfe4..0000000000000000000000000000000000000000 --- a/source/mtllight/sxmtllight.cpp +++ /dev/null @@ -1,1177 +0,0 @@ - -/*********************************************************** -Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 -See the license in LICENSE -***********************************************************/ - -#define SXMATERIAL_LIGTH_VERSION 1 - -#include "sxmtllight.h" -#include "ml_data.h" - -#include "light.h" -#include "material.h" - -#if !defined(DEF_STD_REPORT) -#define DEF_STD_REPORT -report_func g_fnReportf = DefReport; -#endif - -CLights* ArrLights = 0; -CMaterials* ArrMaterials = 0; - -#define ML_PRECOND(retval) if(!ArrLights){LibReport(-1, "%s - sxmtlligth is not init", GEN_MSG_LOCATION); return retval;} - -//########################################################################## - -SX_LIB_API long SML_0GetVersion() -{ - return SXMATERIAL_LIGTH_VERSION; -} - -SX_LIB_API void SML_Dbg_Set(report_func rf) -{ - g_fnReportf = rf; -} - -SX_LIB_API void SML_0Create(const char *szName, bool isUnic) -{ - if (szName && strlen(szName) > 1) - { - if (isUnic) - { - HANDLE hMutex = CreateMutex(NULL, FALSE, szName); - if (GetLastError() == ERROR_ALREADY_EXISTS) - { - CloseHandle(hMutex); - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - none unic name", GEN_MSG_LOCATION); - } - else - { - MLSet::MLInit(); - MLSet::ReCalcSize(); - ArrLights = new CLights(); - ArrMaterials = new CMaterials(); - } - } - else - { - MLSet::MLInit(); - MLSet::ReCalcSize(); - ArrLights = new CLights(); - ArrMaterials = new CMaterials(); - } - } - else - LibReport(REPORT_MSG_LEVEL_ERROR, "%s - not init argument [name]", GEN_MSG_LOCATION); -} - -SX_LIB_API void SML_AKill() -{ - mem_delete(ArrLights) - mem_delete(ArrMaterials); -} - -SX_LIB_API void SML_OnLostDevice() -{ - ML_PRECOND(_VOID); - ArrLights->onLostDevice(); - ArrMaterials->onLostDevice(); -} - -SX_LIB_API void SML_OnResetDevice() -{ - ML_PRECOND(_VOID); - - MLSet::ReCalcSize(); - ArrLights->onResetDevice(); - ArrMaterials->onResetDevice(); - - MLSet::IDsRenderTargets::HowAdaptedLum = 0; -} - -SX_LIB_API void SML_Update(DWORD timeDelta) -{ - static const int *r_win_width = GET_PCVAR_INT("r_win_width"); - static const int *r_win_height = GET_PCVAR_INT("r_win_height"); - - static const float *r_default_fov = GET_PCVAR_FLOAT("r_default_fov"); - - if (ArrMaterials) - ArrMaterials->update(timeDelta); - - MLSet::RefMProjPlane = SMMatrixPerspectiveFovLH(*r_default_fov, float(*r_win_width) / float(*r_win_height), MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); - MLSet::RefMProjCube = SMMatrixPerspectiveFovLH(SM_PI * 0.5f, 1, MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); -} - -SX_LIB_API void SML_LigthsSettLCoefSizeDepth(float fCoef) -{ - ML_PRECOND(_VOID); - - MLSet::CoefSizeDepthMapForLocal = fCoef; - MLSet::ReCalcSize(); - SML_OnLostDevice(); - SML_OnResetDevice(); -} - -SX_LIB_API void SML_LigthsSettGCoefSizeDepth(float fCoef) -{ - ML_PRECOND(_VOID); - - MLSet::CoefSizeDepthMapForGlobal = fCoef; - MLSet::ReCalcSize(); - SML_OnLostDevice(); - SML_OnResetDevice(); - -} - -SX_LIB_API float SML_LigthsGettLCoefSizeDepth() -{ - ML_PRECOND(-1); - - return MLSet::CoefSizeDepthMapForLocal; -} - -SX_LIB_API float SML_LigthsGettGCoefSizeDepth() -{ - ML_PRECOND(-1); - return MLSet::CoefSizeDepthMapForGlobal; -} - -//############################################################################# - -SX_LIB_API void SML_LigthsClear() -{ - ML_PRECOND(_VOID); - - ArrLights->clear(); -} - -SX_LIB_API void SML_LigthsClearIDArr() -{ - ML_PRECOND(_VOID); - - ArrLights->clearIDArr(); -} - -SX_LIB_API int SML_LigthsGetCount() -{ - ML_PRECOND(-1); - - return ArrLights->getCountLights(); -} - -SX_LIB_API bool SML_LigthsGetExists(ID id) -{ - ML_PRECOND(false); - - return ArrLights->getExists(id); -} - - -SX_LIB_API ID SML_LigthsCreatePoint(const float3 *pCenter, float fDist, const float3 *pColor, bool isGlobal, bool isShadowed/*, const char* bound_volume*/) -{ - ML_PRECOND(-1); - return ArrLights->createPoint(-1, pCenter, fDist, pColor, isGlobal, isShadowed/*, 0*/); -} - -SX_LIB_API ID SML_LigthsCreateDirection(const float3 *pPos, float fDist, const float3 *pColor, const SMQuaternion *qOrient, float fTopRadius, float fAngle, bool isShadow/*, const char* bound_volume*/) -{ - ML_PRECOND(-1); - return ArrLights->createDirection(-1, pPos, fDist, pColor, qOrient, fTopRadius, fAngle, isShadow/*, 0*/); -} - -SX_LIB_API void SML_LigthsRender(ID id, DWORD timeDelta) -{ - ML_PRECOND(_VOID); - ArrLights->render(id, timeDelta); -} - -SX_LIB_API ID SML_LigthsGetGlobal() -{ - ML_PRECOND(-1); - return ArrLights->getLightGlobal(); -} - -SX_LIB_API bool SML_LigthsGetCastGlobalShadow() -{ - ML_PRECOND(false); - return ArrLights->getCastGlobalShadow(); -} - -SX_LIB_API void SML_LigthsSetCastGlobalShadow(bool isShadowed) -{ - ML_PRECOND(_VOID); - return ArrLights->setCastGlobalShadow(isShadowed); -} - -SX_LIB_API void SML_LigthsGetColor(ID id, float3 *pColor) -{ - ML_PRECOND(_VOID); - ArrLights->getLightColor(id, pColor); -} - -SX_LIB_API void SML_LigthsSetColor(ID id, const float3 *pColor) -{ - ML_PRECOND(_VOID); - ArrLights->setLightColor(id, pColor); -} - -SX_LIB_API void SML_LigthsGetPos(ID id, float3 *pPos, bool isGreal) -{ - ML_PRECOND(_VOID); - ArrLights->getLightPos(id, pPos, isGreal); -} - -SX_LIB_API float SML_LigthsGetPower(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightPower(id); -} - -SX_LIB_API float SML_LigthsGetDist(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightDist(id); -} - -SX_LIB_API void SML_LigthsSetPos(ID id, const float3 *pPos, bool isGreal) -{ - ML_PRECOND(_VOID); - ArrLights->setLightPos(id, pPos, isGreal); -} - -SX_LIB_API void SML_LigthsGetOrient(ID id, SMQuaternion *pQ) -{ - ML_PRECOND(_VOID); - ArrLights->getLightOrient(id, pQ); -} - -SX_LIB_API void SML_LigthsSetOrient(ID id, const SMQuaternion *pQ) -{ - ML_PRECOND(_VOID); - ArrLights->setLightOrient(id, pQ); -} - -SX_LIB_API LTYPE_LIGHT SML_LigthsGetType(ID id) -{ - ML_PRECOND(LTYPE_LIGHT_NONE); - return ArrLights->getLightType(id); -} - -SX_LIB_API bool SML_LigthsComVisibleForFrustum(ID id, const IFrustum *pFrustum) -{ - ML_PRECOND(false); - return ArrLights->comVisibleForFrustum(id, pFrustum); -} - -SX_LIB_API bool SML_LigthsGetVisibleForFrustum(ID id) -{ - ML_PRECOND(false); - return ArrLights->getVisibleForFrustum(id); -} - -SX_LIB_API float SML_LigthsComDistFor(ID id, const float3 *pPos) -{ - ML_PRECOND(-1); - return ArrLights->comDistFor(id, pPos); -} - -SX_LIB_API float SML_LigthsGetDistFor(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getDistFor(id); -} - -SX_LIB_API void SML_LigthsComVisibleFrustumDistFor(const IFrustum *pFrustum, const float3 *pPos) -{ - ML_PRECOND(_VOID); - return ArrLights->comVisibleFrustumDistFor(pFrustum, pPos); -} - -SX_LIB_API bool SML_LigthsGetEnable(ID id) -{ - ML_PRECOND(false); - return ArrLights->getLightEnable(id); -} - -SX_LIB_API void SML_LigthsSetEnable(ID id, bool isEnable) -{ - ML_PRECOND(_VOID); - return ArrLights->setLightEnable(id, isEnable); -} - -SX_LIB_API bool SML_LigthsGetShadowed(ID id) -{ - ML_PRECOND(false); - return ArrLights->getLightShadowed(id); -} - -SX_LIB_API bool SML_LigthsGet4Or3SplitsG(ID id) -{ - ML_PRECOND(0); - return ArrLights->get4Or3Splits(id); -} - -SX_LIB_API void SML_LigthsSet4Or3SplitsG(ID id, bool is4or3) -{ - ML_PRECOND(_VOID); - - ArrLights->set4Or3Splits(id, is4or3); -} - -SX_LIB_API IDirect3DTexture9* SML_LigthsGetShadow() -{ - ML_PRECOND(0); - return ArrLights->getShadow2(); -} - -SX_LIB_API void SML_LigthsShadowNull() -{ - ML_PRECOND(_VOID); - return ArrLights->shadowNull(); -} - -SX_LIB_API void SML_LigthsShadowRenderBegin(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->shadowRenderBegin(id); -} - -SX_LIB_API void SML_LigthsShadowRenderEnd(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->shadowRenderEnd(id); -} - -SX_LIB_API void SML_LigthsShadowRenderPre(ID id, int iCube) -{ - ML_PRECOND(_VOID); - ArrLights->shadowRenderPre(id, iCube); -} - -SX_LIB_API void SML_LigthsShadowRenderPost(ID id, int iCube) -{ - ML_PRECOND(_VOID); - ArrLights->shadowRenderPost(id, iCube); -} - -SX_LIB_API IFrustum* SML_LigthsGetFrustum(ID id, int iHow) -{ - ML_PRECOND(0); - return ArrLights->getLightFrustum(id, iHow); -} - -SX_LIB_API void SML_LigthsUpdateGFrustums(ID id, int iSplit, const float3 *pPos, const float3 *pDir) -{ - ML_PRECOND(_VOID); - return ArrLights->updateLightGFrustums(id, iSplit, pPos, pDir); -} - -SX_LIB_API void SML_LigthsShadowSetShaderOfTypeMat(ID id, int iTypeMaterial, const float4x4 *pWorld) -{ - ML_PRECOND(_VOID); - ArrLights->initShaderOfTypeMaterial(id, iTypeMaterial, pWorld); -} - -SX_LIB_API void SML_LigthsShadowGen(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->shadowGen2(id); -} - -SX_LIB_API void SML_LigthsShadowSoft(bool isRandom, float fSize, bool isFirst) -{ - ML_PRECOND(_VOID); - ArrLights->shadowSoft(isRandom, fSize, isFirst); -} - - - -SX_LIB_API ID SML_LigthsCreateCopy(ID id) -{ - ML_PRECOND(-1); - return ArrLights->createCopy(id); -} - -SX_LIB_API void SML_LigthsDeleteLight(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->deleteLight(id); -} - -SX_LIB_API char* SML_LigthsGetName(ID id) -{ - ML_PRECOND(0); - return ArrLights->getLightName(id); -} - -SX_LIB_API void SML_LigthsSetName(ID id, const char *szName) -{ - ML_PRECOND(_VOID); - ArrLights->setLightName(id, szName); -} - - -SX_LIB_API void SML_LigthsSetAngle(ID id, float fAngle) -{ - ML_PRECOND(_VOID); - ArrLights->setLightAngle(id, fAngle, true); -} - -SX_LIB_API void SML_LigthsSetTopRadius(ID id, float fTopRadius) -{ - ML_PRECOND(_VOID); - ArrLights->setLightTopRadius(id, fTopRadius); -} - -SX_LIB_API void SML_LigthsSetDist(ID id, float fRadiusHeight, bool isCreate) -{ - ML_PRECOND(_VOID); - ArrLights->setLightDist(id, fRadiusHeight, isCreate); -} - - -SX_LIB_API float SML_LigthsGetShadowBias(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getShadowBias(id); -} - -SX_LIB_API void SML_LigthsSetShadowBias(ID id, float fBias) -{ - ML_PRECOND(_VOID); - return ArrLights->setShadowBias(id, fBias); -} - -SX_LIB_API void SML_LigthsSetShadowBlurPixel(ID id, float fBlurPixel) -{ - ML_PRECOND(_VOID); - ArrLights->setShadowBlurPixel(id, fBlurPixel); -} - -SX_LIB_API float SML_LigthsGetShadowBlurPixel(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getShadowBlurPixel(id); -} -SX_LIB_API void SML_LigthsSetShadowLocalNear(ID id, float fNear) -{ - ML_PRECOND(_VOID); - ArrLights->setShadowLocalNear(id, fNear); -} - -SX_LIB_API float SML_LigthsGetShadowLocalNear(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getShadowLocalNear(id); -} - -SX_LIB_API void SML_LigthsSetShadowLocalFar(ID id, float fFar) -{ - ML_PRECOND(_VOID); - ArrLights->setShadowLocalFar(id, fFar); -} - -SX_LIB_API float SML_LigthsGetShadowLocalFar(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getShadowLocalFar(id); -} - -SX_LIB_API void SML_LigthsSetCubeEdgeEnable(ID id, int iEdge, bool isEnable) -{ - ML_PRECOND(_VOID); - ArrLights->setLightCubeEdgeEnable(id, iEdge, isEnable); -} - -SX_LIB_API bool SML_LigthsGetCubeEdgeEnable(ID id, int iEdge) -{ - ML_PRECOND(false); - return ArrLights->getLightCubeEdgeEnable(id, iEdge); -} - - -SX_LIB_API float SML_LigthsGetAngle(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightAngle(id); -} - -SX_LIB_API float SML_LigthsGetTopRadius(ID id) -{ - ML_PRECOND(-1); - return ArrLights->getLightTopRadius(id); -} - -SX_LIB_API ID SML_LigthsGetIDArr(ID id, ID idOwner, int iHow) -{ - ML_PRECOND(-1); - return ArrLights->getLightIDArr(id, idOwner, iHow); -} - -SX_LIB_API void SML_LigthsSetIDArr(ID id, ID idOwner, int iHow, ID idArr) -{ - ML_PRECOND(_VOID); - ArrLights->setLightIDArr(id, idOwner, iHow, idArr); -} - -SX_LIB_API void SML_LigthsSetTypeShadowed(ID id, LTYPE_SHADOW type) -{ - ML_PRECOND(_VOID); - ArrLights->setLightTypeShadowed(id, type); -} - -SX_LIB_API LTYPE_SHADOW SML_LigthsGetTypeShadowed(ID id) -{ - ML_PRECOND(LTYPE_SHADOW_NONE); - return ArrLights->getLightTypeShadowed(id); -} - -SX_LIB_API bool SML_LigthsCountUpdateUpdate(ID id, const float3 *pViewPos, int iHow) -{ - ML_PRECOND(false); - return ArrLights->lightCountUpdateUpdate(id, pViewPos, iHow); -} - -SX_LIB_API bool SML_LigthsCountUpdateAllowed(ID id, int iHow) -{ - ML_PRECOND(false); - return ArrLights->lightCountUpdateAllowed(id, iHow); -} - -SX_LIB_API void SML_LigthsCountUpdateNull(ID id) -{ - ML_PRECOND(_VOID); - ArrLights->lightCountUpdateNull(id); -} - -SX_LIB_API void SML_LigthsToneMappingCom(DWORD timeDelta, float fAdapted) -{ - ML_PRECOND(_VOID); - ArrLights->toneMappingCom(timeDelta, fAdapted); -} - -SX_LIB_API int SML_LigthsDelGetCount() -{ - ML_PRECOND(-1); - return ArrLights->delGetCount(); -} - -SX_LIB_API LTYPE_LIGHT SML_LigthsDelGetType(ID idKey) -{ - ML_PRECOND(LTYPE_LIGHT_NONE); - return ArrLights->delGetType(idKey); -} - -SX_LIB_API void SML_LigthsDelDel(ID idKey) -{ - ML_PRECOND(_VOID); - ArrLights->delDel(idKey); -} - -SX_LIB_API ID SML_LigthsDelGetIDArr(ID idKey, ID idOwner, int iHow) -{ - ML_PRECOND(-1); - return ArrLights->delGetIDArr(idKey, idOwner, iHow); -} - -//############################################################################# - -SX_LIB_API ID SML_DSGetRT_ID(DS_RT type) -{ - ML_PRECOND(-1); - if (type == DS_RT_COLOR) - return MLSet::IDsRenderTargets::ColorScene; - else if (type == DS_RT_NORMAL) - return MLSet::IDsRenderTargets::NormalScene; - else if (type == DS_RT_PARAM) - return MLSet::IDsRenderTargets::ParamsScene; - else if (type == DS_RT_DEPTH) - return MLSet::IDsRenderTargets::DepthScene; - else if (type == DS_RT_DEPTH0) - return MLSet::IDsRenderTargets::DepthScene0; - else if (type == DS_RT_DEPTH1) - return MLSet::IDsRenderTargets::DepthScene1; - - else if (type == DS_RT_AMBIENTDIFF) - return MLSet::IDsRenderTargets::LightAmbientDiff; - else if (type == DS_RT_SPECULAR) - return MLSet::IDsRenderTargets::LightSpecular; - - else if (type == DS_RT_SCENELIGHT) - return MLSet::IDsRenderTargets::LigthCom; - else if (type == DS_RT_SCENELIGHT2) - return MLSet::IDsRenderTargets::LigthCom2; - - else if (type == DS_RT_ADAPTEDLUM) - return MLSet::IDsRenderTargets::GetCurrAdaptedLum(); - - return -1; -} - -SX_LIB_API IDirect3DTexture9* SML_DSGetRT(DS_RT type) -{ - ML_PRECOND(0); - - ID tmpid = SML_DSGetRT_ID(type); - if (tmpid >= 0) - return SGCore_RTGetTexture(tmpid); - else - return 0; -} - -//############################################################################# - -SX_LIB_API ID SML_MtlLoad(const char *szName, MTLTYPE_MODEL mtl_type) -{ - ML_PRECOND(-1); - - return ArrMaterials->mtlLoad(szName, mtl_type); -} - -SX_LIB_API void SML_MtlSave(ID id) -{ - ML_PRECOND(_VOID); - - ArrMaterials->mtlSave(id); -} - -SX_LIB_API MTLTYPE_MODEL SML_MtlGetTypeModel(ID id) -{ - ML_PRECOND(MTLTYPE_MODEL_STATIC); - - return ArrMaterials->getTypeModel(id); -} - -SX_LIB_API UINT SML_MtlGetSort(ID id) -{ - ML_PRECOND(0); - - return ArrMaterials->mtlGetSort(id); -} - -SX_LIB_API void SML_MtlSetTypeModel(ID id, MTLTYPE_MODEL type_model) -{ - ML_PRECOND(_VOID); - - ArrMaterials->setTypeModel(id, type_model); -} - -SX_LIB_API long SML_MtlGetCount() -{ - ML_PRECOND(-1); - - return ArrMaterials->getCount(); -} - -SX_LIB_API void SML_MtlRender(ID id, const float4x4 *pWorld) -{ - ML_PRECOND(_VOID); - ArrMaterials->render(id, pWorld); -} - -SX_LIB_API void SML_MtlRenderStd(MTLTYPE_MODEL type, const float4x4 *pWorld, ID idSlot, ID idMtl) -{ - ML_PRECOND(_VOID); - ArrMaterials->renderStd(type, pWorld, idSlot, idMtl); -} - -SX_LIB_API void SML_MtlRenderLight(const float4_t *pColor, const float4x4 *pWorld) -{ - ML_PRECOND(_VOID); - ArrMaterials->renderLight(pColor, pWorld); -} - -SX_LIB_API void SML_MtlSetMainTexture(ID slot, ID id) -{ - ML_PRECOND(_VOID); - ArrMaterials->setMainTexture(slot, id); -} - -SX_LIB_API void SML_MtlSetIsIncrCountSurf(bool bf) -{ - ML_PRECOND(_VOID); - ArrMaterials->setIsIncrCountSurf(bf); -} - -SX_LIB_API bool SML_MtlGetIsIncrCountSurf() -{ - ML_PRECOND(false); - return ArrMaterials->getIsIncrCountSurf(); -} - -SX_LIB_API void SML_MtlNullingCurrCountSurf() -{ - ML_PRECOND(_VOID); - ArrMaterials->nullingCurrCountSurf(); -} - -SX_LIB_API int SML_MtlGetCurrCountSurf() -{ - ML_PRECOND(-1); - return ArrMaterials->getCurrCountSurf(); -} - -SX_LIB_API void SML_MtlSetCurrCountSurf(int iCount) -{ - ML_PRECOND(_VOID); - ArrMaterials->setCurrCountSurf(iCount); -} - -SX_LIB_API void SML_MtlSetForceblyAlphaTest(bool isAlphaTest) -{ - ML_PRECOND(_VOID); - ArrMaterials->setForceblyAlphaTest(isAlphaTest); -} - -SX_LIB_API bool SML_MtlGetForceblyAlphaTest() -{ - ML_PRECOND(false); - return ArrMaterials->getForceblyAlphaTest(); -} - - -SX_LIB_API ID SML_MtlGetStdMtl(MTLTYPE_MODEL type_model) -{ - ML_PRECOND(-1); - return ArrMaterials->getStdMtl(type_model); -} - - -SX_LIB_API void SML_MtlSetPhysicMaterial(ID id, MTLTYPE_PHYSIC type) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetPhysicMaterial(id, type); -} - -SX_LIB_API MTLTYPE_PHYSIC SML_MtlGetPhysicMaterial(ID id) -{ - ML_PRECOND(MTLTYPE_PHYSIC_DEFAULT); - return ArrMaterials->mtlGetPhysicMaterial(id); -} - -SX_LIB_API bool SML_MtlGetUsingAlphaTest(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetUsingAlphaTest(id); -} - -SX_LIB_API void SML_MtlSetUsingAlphaTest(ID id, bool isUsing) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUsingAlphaTest(id, isUsing); -} - - - -SX_LIB_API void SML_MtlRefSetIDArr(ID id, ID idOwner, int iCube, ID idArr) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefSetIDArr(id, idOwner, iCube, idArr); -} - -SX_LIB_API ID SML_MtlRefGetIDArr(ID id, ID idOwner, int iCube) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlRefGetIDArr(id, idOwner, iCube); -} - -SX_LIB_API int SML_MtlDelRefGetCount() -{ - ML_PRECOND(-1); - return ArrMaterials->delRefCount(); -} - -SX_LIB_API ID SML_MtlDelRefGetIDArr(ID idKey, ID idOwner, int iCube) -{ - ML_PRECOND(-1); - return ArrMaterials->delRefGetIDArr(idKey, idOwner, iCube); -} - -SX_LIB_API void SML_MtlDelRefClear() -{ - ML_PRECOND(_VOID); - ArrMaterials->delRefAllDel(); -} - -SX_LIB_API void SML_MtlRefSetMinMax(ID id, const float3_t *pMin, const float3_t *pMax) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefSetMinMax(id, pMin, pMax); -} - -SX_LIB_API void SML_MtlRefPreRenderPlane(ID id, D3DXPLANE *pPlane) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefPreRenderPlane(id, pPlane); -} - -SX_LIB_API const IFrustum* SML_MtlRefGetfrustum(ID id, int iCube) -{ - ML_PRECOND(0); - return ArrMaterials->mtlRefGetfrustum(id, iCube); -} - -SX_LIB_API bool SML_MtlRefIsAllowedRender(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlRefIsAllowedRender(id); -} - -SX_LIB_API void SML_MtlRefPostRenderPlane(ID id) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefPostRenderPlane(id); -} - -SX_LIB_API IDirect3DTexture9* SML_MtlRefGetTexPlane(ID id) -{ - ML_PRECOND(0); - return ArrMaterials->mtlRefPlaneGetTex(id); -} - - - -SX_LIB_API void SML_MtlRefCubeBeginRender(ID id, const float3_t *pCenter) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefCubeBeginRender(id, pCenter); -} - -SX_LIB_API void SML_MtlRefCubePreRender(ID id, int iCube, const float4x4 *pWorld) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefCubePreRender(id, iCube, pWorld); -} - -SX_LIB_API void SML_MtlRefCubePostRender(ID id, int iCube) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefCubePostRender(id, iCube); -} - -SX_LIB_API void SML_MtlRefCubeEndRender(ID id, const float3_t *pViewPos) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefCubeEndRender(id, pViewPos); -} - -SX_LIB_API bool SML_MtlRefUpdateCountUpdate(ID id, const float3_t *pViewPos) -{ - ML_PRECOND(false); - return ArrMaterials->mtlRefUpdateCountUpdate(id, pViewPos); -} - -SX_LIB_API void SML_MtlRefNullingCountUpdate(ID id) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlRefNullingCountUpdate(id); -} - -SX_LIB_API IDirect3DCubeTexture9* SML_MtlRefCubeGetTex(ID id) -{ - ML_PRECOND(0); - return ArrMaterials->refCubeGetTex(id); -} - -//########################################################################## - -SX_LIB_API void SML_MtlReloadMaterial(ID id, const char *szName) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlReLoad(id, szName); -} - -SX_LIB_API void SML_MtlClear(bool isClearRefDel) -{ - ML_PRECOND(_VOID); - ArrMaterials->clear(isClearRefDel); -} - -SX_LIB_API void SML_MtlSetTexture(ID id, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetTexture(id, szTexture); -} - -SX_LIB_API void SML_MtlGetTexture(ID id, char *szName) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetTexture(id, szName); -} - -SX_LIB_API ID SML_MtlGetTextureID(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetTextureID(id); -} - -SX_LIB_API void SML_MtlSetVS(ID id, const char *szPath) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetVS(id, szPath); -} - -SX_LIB_API void SML_MtlGetVS(ID id, char *szName) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetVS(id, szName); -} - -SX_LIB_API void SML_MtlSetPS(ID id, const char *szPath) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetPS(id, szPath); -} - -SX_LIB_API void SML_MtlGetPS(ID id, char *szName) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetPS(id, szName); -} - -SX_LIB_API float SML_MtlGetDurability(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetDurability(id); -} - -SX_LIB_API void SML_MtlSetDurability(ID id, float fDurability) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetDurability(id, fDurability); -} - -SX_LIB_API float SML_MtlGetHitChance(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetHitChance(id); -} - -SX_LIB_API void SML_MtlSetHitChance(ID id, float fHitChance) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetHitChance(id, fHitChance); -} - -SX_LIB_API float SML_MtlGetDensity(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetDensity(id); -} - -SX_LIB_API void SML_MtlSetDensity(ID id, float fDensity) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetDensity(id, fDensity); -} - -//########################################################################## - -SX_LIB_API void SML_MtlSetLighting(ID id, bool isLighting) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetLighting(id, isLighting); -} - -SX_LIB_API bool SML_MtlGetLighting(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetLighting(id); -} - -SX_LIB_API void SML_MtlSetIsTextureLighting(ID id, bool isTexLighting) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetIsTextureLighting(id, isTexLighting); -} - -SX_LIB_API bool SML_MtlGetIsTextureLighting(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetIsTextureLighting(id); -} - -SX_LIB_API void SML_MtlSetTextureLighting(ID id, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetTextureLighting(id, szTexture); -} - -SX_LIB_API void SML_MtlGetTextureLighting(ID id, char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetTextureLighting(id, szTexture); -} - -SX_LIB_API void SML_MtlSetRoughness(ID id, float fRoughness) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetRoughness(id, fRoughness); -} - -SX_LIB_API float SML_MtlGetRoughness(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetRoughness(id); -} - -SX_LIB_API void SML_MtlSetThickness(ID id, float fThickness) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetThickness(id, fThickness); -} - -SX_LIB_API float SML_MtlGetThickness(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetThickness(id); -} - -SX_LIB_API void SML_MtlSetF0(ID id, float fF0) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetF0(id, fF0); -} - -SX_LIB_API float SML_MtlGetF0(ID id) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetF0(id); -} - -SX_LIB_API void SML_MtlSetTransparency(ID id, bool isTransparent) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetTransparency(id, isTransparent); -} - -SX_LIB_API bool SML_MtlGetTransparency(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetTransparency(id); -} - -SX_LIB_API void SML_MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetTypeReflection(id, type); -} - -SX_LIB_API MTLTYPE_REFLECT SML_MtlGetTypeReflection(ID id) -{ - ML_PRECOND(MTLTYPE_REFLECT_NONE); - return ArrMaterials->mtlGetTypeReflection(id); -} - -//************************************************************************** - -SX_LIB_API void SML_MtlSetMaskTex(ID id, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetMaskTex(id, szTexture); -} - -SX_LIB_API void SML_MtlGetMaskTex(ID id, char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetMaskTex(id, szTexture); -} - -SX_LIB_API void SML_MtlSetMRTex(ID id, int iChannel, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetMRTex(id, iChannel, szTexture); -} - -SX_LIB_API void SML_MtlGetMRTex(ID id, int iChannel, char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetMRTex(id, iChannel, szTexture); -} - -SX_LIB_API void SML_MtlSetDTex(ID id, int iChannel, const char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetDTex(id, iChannel, szTexture); -} - -SX_LIB_API void SML_MtlGetDTex(ID id, int iChannel, char *szTexture) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlGetDTex(id, iChannel, szTexture); -} - -SX_LIB_API void SML_MtlSetStdVS(ID id, MTL_SHADERSTD type, bool isSend) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetStdVS(id, type, isSend); -} - -SX_LIB_API bool SML_MtlGetStdVS(ID id, MTL_SHADERSTD type) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetStdVS(id, type); -} - -SX_LIB_API void SML_MtlSetStdPS(ID id, MTL_SHADERSTD type, bool isSend) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetStdPS(id, type, isSend); -} - -SX_LIB_API bool SML_MtlGetStdPS(ID id, MTL_SHADERSTD type) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetStdPS(id, type); -} - - -SX_LIB_API void SML_MtlSetUserDataVS(ID id, int iComponent, float fValue) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUserDataVS(id, iComponent, fValue); -} - -SX_LIB_API float SML_MtlGetUserDataVS(ID id, int iComponent) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetUserDataVS(id, iComponent); -} - -SX_LIB_API void SML_MtlSetUserDataVS_InPS(ID id, bool isSendPS) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUserDataVS_InPS(id, isSendPS); -} - -SX_LIB_API bool SML_MtlGetUserDataVS_InPS(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetUserDataVS_InPS(id); -} - -SX_LIB_API void SML_MtlSetUserDataPS(ID id, int iComponent, float fValue) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUserDataPS(id, iComponent, fValue); -} - -SX_LIB_API float SML_MtlGetUserDataPS(ID id, int iComponent) -{ - ML_PRECOND(-1); - return ArrMaterials->mtlGetUserDataPS(id, iComponent); -} - -SX_LIB_API void SML_MtlSetUserDataPS_InVS(ID id, bool isSendVS) -{ - ML_PRECOND(_VOID); - ArrMaterials->mtlSetUserDataPS_InPS(id, isSendVS); -} - -SX_LIB_API bool SML_MtlGetUserDataPS_InVS(ID id) -{ - ML_PRECOND(false); - return ArrMaterials->mtlGetUserDataPS_InPS(id); -} diff --git a/source/mtllight/sxmtllight.h b/source/mtllight/sxmtllight.h deleted file mode 100644 index edd34cb0c245e1e34a2c065af0fc6f1e3385f0b7..0000000000000000000000000000000000000000 --- a/source/mtllight/sxmtllight.h +++ /dev/null @@ -1,1381 +0,0 @@ - -/*********************************************************** -Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 -See the license in LICENSE -***********************************************************/ - -/*! -\file -Заголовочный файл sxmtllight - библиотеки освещения и материалов -*/ - -/*! \defgroup sxmtllight sxmtllight - библиотека освещения и материалов -@{ -*/ - -#ifndef __SXMTLLIGHT_H -#define __SXMTLLIGHT_H - -#if defined(_DEBUG) -#pragma comment(lib, "sxgcore_d.lib") -#else -#pragma comment(lib, "sxgcore.lib") -#endif - -#undef SX_LIB_API -#define SX_LIB_API extern "C" __declspec (dllimport) -#include - -#ifdef SX_DLL -#undef SX_LIB_API -#define SX_LIB_API extern "C" __declspec (dllexport) -#endif - -#include - -/*! \name Базовые функции библиотеки -@{*/ - -//! версия подсистемы -SX_LIB_API long SML_0GetVersion(); - -//! установить функцию обработки сообщений -SX_LIB_API void SML_Dbg_Set(report_func rf); - -//! инициализция подсистемы -SX_LIB_API void SML_0Create( - const char *szName, //!< присваиваемое имя - bool isUnic = true //!< должна ли подсистема быть уникальной по имени - ); - -//! уничтожить подсистему -SX_LIB_API void SML_AKill(); - -//!@} - -/*! \name Обработка потери/восстановления устройства -@{*/ - -//! вызывать при потрете устройства -SX_LIB_API void SML_OnLostDevice(); - -//! вызывать при восстановлении устройства -SX_LIB_API void SML_OnResetDevice(); - -//!@} - -//! обновление данных всей библиотеки -SX_LIB_API void SML_Update( - DWORD timeDelta //!< время рендера кадра в млсек - ); - -//############################################################################# - -/*! \defgroup sxmtllight_light Освещение - \ingroup sxmtllight - \warning Обращение (идентификация) конкретного света осуществляется посредством идентификатора который выдают создающие функции: - - #SML_LigthsCreatePoint - - #SML_LigthsCreateDirection - Получить идентификатор уже созданного света можно, посредством ключа (key) который лежит в пределах [0, #SML_LigthsGetCount), -передав этот ключ #SML_LigthsGetIDOfKey, которая в случае успеха вернет идентификатор света. -@{*/ - -/*! максимальное количество обновлений статических источников света, в первый момент рендера */ -#define LIGHTS_UPDATE_MAX_COUNT_FOR_STATIC 3 - -/*! \name Дистанции (метрах) при которых будет сниженно или повышено количество отрисовок для локальных источников света -меньше #LIGHTS_UPDATE_L0_DIST - обновление будет каждый кадр\n -больше #LIGHTS_UPDATE_L2_DIST - обновления не будет -@{*/ - -#define LIGHTS_UPDATE_L0_DIST 10 -#define LIGHTS_UPDATE_L1_DIST 30 -#define LIGHTS_UPDATE_L2_DIST 70 - -//!@} - -/*! Коэфициент обновления сплитов глобального света. -Cчитается: LIGHTS_UPDATE_PSSM_SPLIT*number_split - \note Первый сплит обновляется каждый кадр, второй через кадр -*/ -#define LIGHTS_UPDATE_PSSM_SPLIT 1 - -/*! аналогичнен #LIGHTS_UPDATE_PSSM_SPLIT только для 5 сплита (для теней от облаков) */ -#define LIGHTS_UPDATE_PSSM_SPLIT_5 2 - - -/*! стандартное значение верхнего/начального радиуса для направленного света */ -#define LIGHTS_LOCAL_STD_TOP_RADIUS 0.1 - -/*! стандартное значение ближней плоскости отсечения для теней локального света */ -#define LIGHTS_LOCAL_STD_NEAR 0.1 - -/*! максимальная дистанция локального света */ -#define LIGHTS_LOCAL_MAX_DIST 200.f - - -/*! радиус глобального источника */ -#define LIGHTS_GLOBAL_STD_RADIUS 999999 - -/*! отдаленность глобального света (нужно для корректности теней), если не знаете, не трогайте */ -#define LIGHTS_POS_G_MAX 1000 - - -/*! базовое направление направленноого источника света */ -#define LIGHTS_DIR_BASE float3(0, -1, 0) - - -//! типы источников света -enum LTYPE_LIGHT -{ - //! не установленный - LTYPE_LIGHT_NONE = -1, - - //! глобальный - LTYPE_LIGHT_GLOBAL, - - //! точечный - LTYPE_LIGHT_POINT, - - //! направленный - LTYPE_LIGHT_DIR -}; - -//! типы теней источников света -enum LTYPE_SHADOW -{ - //! без теней - LTYPE_SHADOW_NONE = -1, - - //! статичные тени, тень обновляется первые несколько кадров (для корректности), далее не обновляется - LTYPE_SHADOW_STATIC, - - //! полностью динамические тени - LTYPE_SHADOW_DYNAMIC, -}; - -/*! \name Настройки размеров для теней - \note Коэфициента относительно размеров окна рендера, если 1.f то размеры экрана, если 0.5f то размеры экрана * 0.5f -@{*/ - -//! установка коэфициента для локального света -SX_LIB_API void SML_LigthsSettLCoefSizeDepth(float fCoef); - -//! установка коэфициента для глобального света -SX_LIB_API void SML_LigthsSettGCoefSizeDepth(float fCoef); - - -//! возвращение коэфициента для локальный свет -SX_LIB_API float SML_LigthsGettLCoefSizeDepth(); - -//! возвращение коэфициента для глобальный свет -SX_LIB_API float SML_LigthsGettGCoefSizeDepth(); - -//!@} - -//! очистить список света -SX_LIB_API void SML_LigthsClear(); - -//! очистка всех идентификаторов просчетов во всех источниках света -SX_LIB_API void SML_LigthsClearIDArr(); - -//! общее количество света -SX_LIB_API int SML_LigthsGetCount(); - -//! возвращает true если свет с id существует -SX_LIB_API bool SML_LigthsGetExists(ID id); - -//! создать точечный свет (светит во все стороны) -SX_LIB_API ID SML_LigthsCreatePoint( - const float3 *pCenter, //!< центр света (мировая позиция) - float fDist, //!< дистанция, на которую распространяется свет - const float3 *pColor, //!< цвет в пределах 0-1 - bool isGlobal, //!< глобальный ли свет (типа солнца) - bool isShadowed //!< отбрасвыает ли тени свет - ); - -//! создать направленный свет -SX_LIB_API ID SML_LigthsCreateDirection( - const float3 *pPos, //!< позиция света (мировая) - float fDist, //!< дистанция на которую распространяется свет - const float3 *pColor, //!< цвет - const SMQuaternion *qOrient,//!< ориентация - float fTopRadius, //!< верхний (начальный) радиус - float fAngle, //!< угол (в радианах) - bool isShadow //!< отбрасвыает ли тени свет - ); - -//! возвращает тип света -SX_LIB_API LTYPE_LIGHT SML_LigthsGetType(ID id); - -//! создать копию объекта и вернуть на нее id -SX_LIB_API ID SML_LigthsCreateCopy(ID id); - -//! удаление света -SX_LIB_API void SML_LigthsDeleteLight(ID id); - -//! возвращает имя света -SX_LIB_API char* SML_LigthsGetName(ID id); - -//! устанавливает имя света -SX_LIB_API void SML_LigthsSetName(ID id, const char *szName); - -//! отрисовка ограничивающего объема -SX_LIB_API void SML_LigthsRender(ID id, DWORD timeDelta); - -//! в color записывает цвет света -SX_LIB_API void SML_LigthsGetColor(ID id, float3 *pColor); - -//! устанавливает цвет света -SX_LIB_API void SML_LigthsSetColor(ID id, const float3 *pColor); - -//! получить в pos позицию света -SX_LIB_API void SML_LigthsGetPos( - ID id, //!< идентификатор света - float3 *pPos, //!< инициализированный вектор в который будет записана позиция - bool isReal = false //!< true - нужны реальные координаты, false - нужны углы, только для глобального света, во всех остальных случаях не имеет смысла - ); - -//! установить позицию свету -SX_LIB_API void SML_LigthsSetPos( - ID id, //!< идентификатор света - const float3 *pPos, //!< позиция в которую будет перемещен свет - bool isReal = false //!< true - установка реальных координат, false - установка углов, только для глобального света, во всех остальных случаях не имеет смысла - ); - -//! возвращает "значение силы света" для отправки в шейдер (максимальная компонента цвет * дистанция покрытия/#LIGHTS_LOCAL_MAX_DIST) -SX_LIB_API float SML_LigthsGetPower(ID id); - -//! возвращает дистанцию, на которую распространяется свет -SX_LIB_API float SML_LigthsGetDist(ID id); - -//! установка новой дистанции -SX_LIB_API void SML_LigthsSetDist( - ID id, //!< идентификатор света - float fDist, //!< новая дистанция(радиус для точечного и высота для направленного) - bool isCreate = true //!< нужно ли пересоздание объема? (если новая дистанция больше чем текущий ограничивающий объем то надо, в других случаях по усмотрению) - ); - -//! записывает в q ориентацию света -SX_LIB_API void SML_LigthsGetOrient(ID id, SMQuaternion *pQ); - -//! установка ориентации света -SX_LIB_API void SML_LigthsSetOrient(ID id, const SMQuaternion *pQ); - - -//! включен ли свет с идентификатором id -SX_LIB_API bool SML_LigthsGetEnable(ID id); - -//! установить всключен (true) или отключен (false) свет с идентификатором id -SX_LIB_API void SML_LigthsSetEnable(ID id, bool isEnable); - -//! возвращает идентификатор глобального источника света, если он есть, иначе -1 -SX_LIB_API ID SML_LigthsGetGlobal(); - -//! возвращает установлена ли общая тень от глобального источника (все ли в тени) -SX_LIB_API bool SML_LigthsGetCastGlobalShadow(); - -//! установить общую тень для всего от глобального источника (все в тень) -SX_LIB_API void SML_LigthsSetCastGlobalShadow(bool isShadowed); - -//----------------------------------------------------------------------------- - -/*! \name Управление видимостью - \note Отдельный просчет - считает индивидуально для света и тут же возвращает результат просчетов - \note Предварительный просчет - просчет для всего света (к примеру в другом потоке) -@{*/ - -//! виден ли свет в данном фрустуме (отдельный просчет) -SX_LIB_API bool SML_LigthsComVisibleForFrustum(ID id, const IFrustum *pFrustum); - -//! дистанция от viewpos до начала света (отдельный просчет) -SX_LIB_API float SML_LigthsComDistFor(ID id, const float3 *pViewPos); - -//! просчет видимости и расстояния от наблюдателя viewpos до начала света, для каждого света (предварительный просчет) -SX_LIB_API void SML_LigthsComVisibleFrustumDistFor(const IFrustum *pFrustum, const float3 *pViewPos); - - -//! виден ли свет в просчитанном фрустуме -SX_LIB_API bool SML_LigthsGetVisibleForFrustum(ID id); - -//! просчитанная дистанция от позиции наблюдателя до начала света -SX_LIB_API float SML_LigthsGetDistFor(ID id); - -//!@} - -//----------------------------------------------------------------------------- - -/*! \name Настройки для направленного света -@{*/ - -//! возвращает угол, актуально только для направленного и света -SX_LIB_API float SML_LigthsGetAngle(ID id); - -//! установить угол, актуально только для направленного и света -SX_LIB_API void SML_LigthsSetAngle(ID id, float fAngle); - -//! возвращает верхний радиус, актуально только для направленного и света -SX_LIB_API float SML_LigthsGetTopRadius(ID id); - -//! устанавливает верхний радиус, актуально только для направленного и света -SX_LIB_API void SML_LigthsSetTopRadius(ID id, float fTopRadius); - -//!@} - -//----------------------------------------------------------------------------- - -/*! \name Настройки для точечного света -@{*/ - -/*! установить "рисовать ли в указанную грань cubemap тени" - \warning Актуально только когда свет может отбрасывать тени - */ -SX_LIB_API void SML_LigthsSetCubeEdgeEnable( - ID id, //!< идентификатор света - int iEdge, //!< номер стороны/грани cubemap [0,5] - bool iEnable //!< true - рисовать, false - не рисовать - ); - -//! получить текущее значение "рисовать ли в указанную грань cubemap тени" -SX_LIB_API bool SML_LigthsGetCubeEdgeEnable( - ID id, //!< идентификатор света - int iEdge //!< номер стороны/грани cubemap [0,5] - ); - -//!@} - -//----------------------------------------------------------------------------- - -/*! \defgroup sxmtllight_light_shadow Управление тенями - \ingroup sxmtllight_light - \note Для генерации теней используется один render target full screen - \note Для сглаживания используется еще один аналогичный render target и первый render target. При сглаживании внутри меняется только счетчик, который меняет их местами - \note Так как используется всего один render target для генерации теней то есесно в текущий момент времени можно сгенерировать и сгладить тень только для одного света - \note Для теней от глобального света используется техника PSSM (Parallel-Split Shadow Mapping) на 3/4 сплита для объектов уровня (3 или 4 сплита можно настроить #SML_LigthsSet4Or3SplitsG) - \note Для теней от локального света используется техника Shadow Mapping в двух вариациях: - - для точечного света используется cubemap - - для направленного света - обычная техника Shadow Mapping -@{*/ - -//! отбрасывает ли свет тени -SX_LIB_API bool SML_LigthsGetShadowed(ID id); - -//! возвращает true в случае если установлено 4 сплита для PSSM, иначе (установлено 3 сплита) false -SX_LIB_API bool SML_LigthsGet4Or3SplitsG(ID id); - -//! установка количества сплитов (false - 3, true - 4) для PSSM -SX_LIB_API void SML_LigthsSet4Or3SplitsG(ID id, bool is4or3); - -/*! устанавливает шейдеры и передает им данные на основании типа материала, поддерживаются все типы MTL_TYPE_*/ -SX_LIB_API void SML_LigthsShadowSetShaderOfTypeMat(ID id, int typemat, const float4x4 *pWorld); - -/*! \name Управление обновлениями теней - \note Так как основная задумка это real-time рендер то для этого нужны упрощения, одним из таковых является обновление теней от света, которое может происходить не каждый кадр -@{*/ - -//! установка динамики обработки теней -SX_LIB_API void SML_LigthsSetTypeShadowed( - ID id, //!< идентификатор света - LTYPE_SHADOW type //!< значение из перечисления #LTYPE_SHADOW - ); - -//! возвращает тип динамики теней (одно из значений #LTYPE_SHADOW) -SX_LIB_API LTYPE_SHADOW SML_LigthsGetTypeShadowed(ID id); - -//! производит обработку данных затем возвращает разрешено ли обновлять тени, увеличивает внутрений счетчик, поэтому необходимо вызывать только когда надо -SX_LIB_API bool SML_LigthsCountUpdateUpdate( - ID id, //!< идентификатор света - const float3 *pViewPos, //!< позиция камеры для которой обновляем, на основании расстояния будет произведен расчет обновления - int iHow = -1 //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//! разрешено ли обновлять тени, в отличии от #SML_LigthsUpdateCountUpdate не увеличивает внутренний счетчик -SX_LIB_API bool SML_LigthsCountUpdateAllowed( - ID id, //!< идентификатор света - int iHow = -1 //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//! сбросить счетчик обновлений и обновлять до предела тени -SX_LIB_API void SML_LigthsCountUpdateNull(ID id); - -//!@} - - -/*! \name Управление циклами рендера в карты глубин - Для локального направленного света: - \code - SML_LigthsShadowRenderBegin(id); - //рендер того что должно отбросить тени - SML_LigthsShadowRenderEnd(id); - \endcode - Для глобального и точечного: - \code - SML_LigthsShadowRenderBegin(id); - SML_LigthsShadowRenderPre(id, cube); - //рендер того что должно отбросить тени - SML_LigthsShadowRenderPost(id, cube); - SML_LigthsShadowRenderEnd(id); - \endcode - Где cube для точечного это номер стороны cubemap [0-5] в которую будет осуществлен рендер, а для глобального это номер сплита. -@{*/ - -//! подготовительные процедуры -SX_LIB_API void SML_LigthsShadowRenderBegin(ID id); - -//! завершающие процедуры -SX_LIB_API void SML_LigthsShadowRenderEnd(ID id); - -//! подготовительные процедур перед рендером для сплита/стороны -SX_LIB_API void SML_LigthsShadowRenderPre( - ID id, //!< идентификатор света - int iCube //!< для точечного света - сторона cubemap [0-5] для глобального света номер сплита - ); - -//! завершающие процедур перед рендером для сплита/стороны -SX_LIB_API void SML_LigthsShadowRenderPost( - ID id, //!< идентификатор света - int iCube //!< для точечного света - сторона cubemap [0-5] для глобального света номер сплита - ); - -//!@} - -//! обнуление карты теней, необходимо вызывать перед генерацией теней посредством функции #SML_LigthsGenShadow -SX_LIB_API void SML_LigthsShadowNull(); - -//! генерация тени на основе уже отработанной информации о затенении, перед вызовов этой функции необходимо вызывать #SML_LigthsShadowNull -SX_LIB_API void SML_LigthsShadowGen(ID id); - -//! возвращает текстуру с тенями (если вызывались функции сглаживания) то вренутся сглаженная -SX_LIB_API IDirect3DTexture9* SML_LigthsGetShadow(); - -//! сглаживание текущей тени -SX_LIB_API void SML_LigthsShadowSoft( - bool isRandSam, //!< использовать ли смещение по случайному направлению - float fSize, //!< коэфициент увеличения размера пикселя для размытия - bool isFirst = false //!< впервые ли вызывается размытие для текущей тени, каждый раз когда тень еще не сглажена, но сгенерирована, нужно указывать false - ); - -//! возвращает указатель фрустума света -SX_LIB_API IFrustum* SML_LigthsGetFrustum( - ID id, //!< идентификатор света - int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//! обновление фрустума глобального света -SX_LIB_API void SML_LigthsUpdateGFrustums( - ID id, //!< идентификатор света - int iSplit, //!< номер сплита - const float3 *pPos, //!< позиция наблюдателя - const float3 *pDir //!< направление взгляда наблюдателя - ); - -/*! \name Управление настройками для генерации глубины/тени -@{*/ - -//! получить текущее смещение (bias) при генерации глубины -SX_LIB_API float SML_LigthsGetShadowBias(ID id); - -//! установить текущее смещение (bias) при генерации глубины -SX_LIB_API void SML_LigthsSetShadowBias(ID id, float fBias); - - -//! установить размерность размытия (в пикселя) при геренации тени -SX_LIB_API void SML_LigthsSetShadowBlurPixel(ID id, float fBlurPixel); - -//! получить текущее значение размерности (в пикселях) при генерации тени -SX_LIB_API float SML_LigthsGetShadowBlurPixel(ID id); - - -//! установить значение ближней плоскостью отсечения для теней (локальный свет) -SX_LIB_API void SML_LigthsSetShadowLocalNear(ID id, float fNear); - -//! получить текущее значение ближней плоскостью отсечения для теней (локальный свет) -SX_LIB_API float SML_LigthsGetShadowLocalNear(ID id); - -/*! установка дальней плоскостью отсечения для теней (локальный свет) - \note Иногда возникают артефакты и если отрегулировать это значение то все становится на свои места, тесты показали что в основном при ошибках, увеличение этого значения решало проблемы -*/ -SX_LIB_API void SML_LigthsSetShadowLocalFar( - ID id, //!< идентификатор света - float fFar //!< значение дальней плоскости отсечения (дальность видимости теней), обычно это значение = дальность света - ); - -//! возвращает значение дальней плоскости отсечения (дальности видимости теней) -SX_LIB_API float SML_LigthsGetShadowLocalFar(ID id); - -//!@} - -//----------------------------------------------------------------------------- - -/*! \name Управление массивами обработки данных для рендера (к примеру от геометрии, растительности и прочего) - Cделано для того чтобы отделить просчеты видимости (если они нужны) от рендера. - К примеру можно рассчитать видимости в одном потоке а рисовать в основном. -@{ -*/ - -//! возвращает идентификатор в случае успеха, иначе <0 -SX_LIB_API ID SML_LigthsGetIDArr( - ID id, //!< идентификатор света - ID idOwner, //!< идентификатор объекта/системы вообще того что выдало идентификатор массива - int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//! установить идентификатор -SX_LIB_API void SML_LigthsSetIDArr( - ID id, //!< идентификатор света - ID idOwner, //!< идентификатор объекта/системы вообще того что выдало идентификатор массива - int iHow, //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ID idArr //!< номер массива обработки от объекта который надо будет обрабатывать на видимость - ); - -//!@} - -//!@} sxmtllight_light_shadow - -//! обработка tone mapping -SX_LIB_API void SML_LigthsToneMappingCom( - DWORD timeDelta, //!< время рендера кадра в млсек - float fFactorAdapted = 0.3 //!< на сколько быстро "глаз" привыкнет к освещению (0,1] (медленно, быстро] - ); - -/*! \name Функции обработки удаленного света - При удалении света он помещается в специальный массив удаленных объектов, -это связано с тем что свет может содержать в себе данные которые требуют очистки памяти вне данной реализации, -к примеру идентификаторы массивов просчетов видимости. \n - Поэтому необходимо вручную удалять (уже после удаленяи функцией #SML_LigthsDeleteLight) удаленные объекты света. - \note Доступ к элементам массива удаленных объектов света осуществляется посредством порядкового номера в массиве (ключа key), то есть можно пройтись по массиву циклом. -@{*/ - -//! возвращает количество удаленных объектов света которые требуют удаления -SX_LIB_API int SML_LigthsDelGetCount(); - -//! возвращает тип удаленного объекта света, значения из #LightsTypeLight -SX_LIB_API LTYPE_LIGHT SML_LigthsDelGetType(ID key); - -//! удаляет (окончательно) удаленный объект света -SX_LIB_API void SML_LigthsDelDel(ID key); - -//! возвращает идентификатор, если был передан, иначе <0 -SX_LIB_API ID SML_LigthsDelGetIDArr( - ID key, //!< порядковый номер объекта света в массиве удаленного света - ID idOwner, //!< идентификатор того что выдало идентификатор массива - int iHow //!< номер сплита для глобального, 0 для направленного, и номер стороны для точечного - ); - -//!@} - -//!@} sxmtllight_light - -//############################################################################# - -/*! \defgroup sxmtllight_ds Render targets для deferred shading - \ingroup sxmtllight -@{*/ - -//! типы render targets -enum DS_RT -{ - //! цвет rgba8 - DS_RT_COLOR = 0, - - //! нормали (включая микрорельеф) rfb10a2 - DS_RT_NORMAL, - - //! параметры освещения rgba8 - DS_RT_PARAM, - - //! глубина r16f, непрозрачные материалы - DS_RT_DEPTH, - - //! глубина r16f, непрозрачные материалы - DS_RT_DEPTH0, - - //! глубина r16f, непрозрачные и полупрозрачные пиксели, однако прозрачные (если есть) будут перекрывать непрозрачные, и в этом случае их глубина будет 1 то есть максимальной(для идентификации) - DS_RT_DEPTH1, - - - //! эмбиент цвет (цвет света rgb) и диффузное освещение (a) rgba16f - DS_RT_AMBIENTDIFF, - - //! блики r16f - DS_RT_SPECULAR, - - //! освещенная сцена rgba16 - DS_RT_SCENELIGHT, - - //! освещенная сцена rgba16 - DS_RT_SCENELIGHT2, - - //! текущий rt адаптации глаза к освещению r16f - DS_RT_ADAPTEDLUM -}; - -//! id render target по его типу -SX_LIB_API ID SML_DSGetRT_ID(DS_RT type); - -//! текстура render target по его типу -SX_LIB_API IDirect3DTexture9* SML_DSGetRT(DS_RT type); - -//!@} sxmtllight_ds - -//############################################################################# - -/*! \defgroup sxmtllight_mtl Система материалов - \ingroup sxmtllight -@{*/ - -/*! максимальная длина имени директории материала */ -#define MTL_MAX_SIZE_DIR SXGC_LOADTEX_MAX_SIZE_DIR - -/*! максимальная длина имени материала (без директории) */ -#define MTL_MAX_SIZE_NAME SXGC_LOADTEX_MAX_SIZE_NAME - -/*! максимальное количество обновлений статических отражений, в первый момент рендера */ -#define MTL_REF_UPDATE_MAX_COUNT_FOR_STATIC 3 - -/*! \name Дистанции при которых будут сниженно или повышено количество отрисовок для отражений -меньше #MTL_REF_UPDATE_L0_DIST - обновление будет каждый кадр -больше #MTL_REF_UPDATE_L2_DIST - обновления не будет -@{*/ - -#define MTL_REF_UPDATE_L0_DIST 10 -#define MTL_REF_UPDATE_L1_DIST 30 -#define MTL_REF_UPDATE_L2_DIST 70 - -//!@} - -/*! \name Параметры альфа теста - В данной реалзиации 2 вида альфа теста, принудительный (#SML_MtlSetForceblyAlphaTest) и назначаемый непосредственно материалом - \note функция альфа теста D3DCMP_GREATEREQUAL -@{*/ - -/*! значение свободного альфа теста (назначаемого материалом) */ -#define MTL_ALPHATEST_FREE_VALUE 64 - -/*! значение принудительного альфа теста */ -#define MTL_ALPHATEST_FORCEBLY_VALUE 8 - -//!@} - -/*! \name Значения параметров освещения по умолчанию - Данные значения по умолчанию будут применены к материалами которые не удалось загрузить, либо к стандартным материалам -@{*/ - -//! занчение шероховатости по умолчанию -#define MTL_LIGHTING_DEFAULT_ROUGHNESS 250.f/255.f - -//! значение f0 (отражательной способности поверхности) по умолчанию -#define MTL_LIGHTING_DEFAULT_F0 2.f/255.f - -//! значение thickness (толщина - на сколько будет использована диффузная составляющая, для твердых поверхностей - 1, для листьев деревьев и травы <1) по умолчанию -#define MTL_LIGHTING_DEFAULT_THICKNESS 255.f/255.f - -//!@} - -/*! \name Параметры отражений -@{*/ - -/*! размер текстур с отражениями */ -#define MTL_REF_TEX_SIZE 512 - -/*! ближняя плоскость отсечения */ -#define MTl_REF_PROJ_NEAR 0.25 - -/*! дальняя плоскость отсечения, или дистанция на которую будет рендер всего в текстуру отражений */ -#define MTl_REF_PROJ_FAR 100 - -//!@} - -/*! \name Виртуальные директории - \warning Имя виртуальной директории должно быть единичным символом (сделано для простоты сравнения), -и как следствие нежелательно использоавть реальную директорию с таким именем для текстур либо материалов, -и реальные директории не должны начинаться с данных символов -@{*/ - -//! имя виртуальной директории по умолчанию для "ручных" текстур с параметрами освещения -#define MTL_VIRTUAL_DIR_HAND_MTL '0' - -//! имя виртуальной директории по умолчанию для стандартных (встроенных) материалов -#define MTL_VIRTUAL_DIR_STD_MTL "mtrldef" - -//!@} - -/*! \name Текстурные регистры -Распределение регистров между текстурами которые будут отправляться для формирования данных -@{*/ - -/*!< основная текстура */ -#define MTL_TEX_R_MAIN 0 - -/*!< маска */ -#define MTL_TEX_R_MASK 1 - -/*! стартовый регистр для детальных текстур - \warning 4 следующих (включая указанный) будует заполнены детальными текстурами, поэтому никакие другие текстуры в [MTL_TEX_R_DETAIL, MTL_TEX_R_DETAIL+3] не должны отправляться - \note Текстуры для каждого канала будут отправляться последовательно: r, g, b, a - MTL_TEX_R_DETAIL, MTL_TEX_R_DETAIL + 1, MTL_TEX_R_DETAIL + 2, MTL_TEX_R_DETAIL + 3 -*/ -#define MTL_TEX_R_DETAIL 2 - -/*! стартовый регистр для микрорельефных текстур -\warning 4 следующих (включая указанный) будует заполнены микрорельефными текстурами, поэтому никакие другие текстуры в [MTL_TEX_R_MICRO, MTL_TEX_R_MICRO+3] не должны отправляться -\note Текстуры для каждого канала будут отправляться последовательно: r, g, b, a - MTL_TEX_R_MICRO, MTL_TEX_R_MICRO + 1, MTL_TEX_R_MICRO + 2, MTL_TEX_R_MICRO + 3 -*/ -#define MTL_TEX_R_MICRO 6 - - -/*! текстура с параметрами освещения */ -#define MTL_TEX_R_PARAM_LIGHT 10 - -/*! текстура с отражениями */ -#define MTL_TEX_R_REFLECTION 12 - -/*! текстура с преломлениями */ -#define MTL_TEX_R_REFRACTION 13 - -/*! текстура с текущей глубиной */ -#define MTL_TEX_R_CURR_DEPTH 14 - -//!@} - -//! типы отражений -enum MTLTYPE_REFLECT -{ - //! нет отражения - MTLTYPE_REFLECT_NONE, - - //! плоское - MTLTYPE_REFLECT_PLANE, - - //! объемное динамическое - MTLTYPE_REFLECT_CUBE_DYNAMIC, - - //! объемное статическое, обработка идет первые несколько кадров, затем не обновляется - MTLTYPE_REFLECT_CUBE_STATIC -}; - -//! сорт материала -enum MTLSORT -{ - //! непрозрачный - MTLSORT_OPAQUE = 0x00000001, - - //! прозрачный - MTLTYPE_TRANSPARENCY = 0x00000010, - - //! непрозрачный - MTLSORT_LIGHTED = 0x00000100, - - //! прозрачный - MTLTYPE_ULIT = 0x00001000, - - //! непрозрачный освещаемый - /*MTLSORT_OPAQUE_LIGHTED, - - //! непрозрачный не освещаемый - MTLSORT_OPAQUE_UNLIT,*/ - - - //! полупрозрачный освещаемый - /*MTLTYPE_TRANSPARENCY_LIGHTED, - - //! полупрозрачный не освещаемый - MTLTYPE_TRANSPARENCY_UNLIT,*/ -}; - -/*! \name Возможные слои -@{*/ - -//! непрозрачные неосвещаемые -#define MTLTYPE_LAYER_OPAQUE_UNLIT 0.0f - -//! прозрачные неосвещаемые -#define MTLTYPE_LAYER_TRANSPARENT_UNLIT 0.666667f - -//! непрозрачные освещаемые -#define MTLTYPE_LAYER_OPAQUE_LIGHT 0.333333f - -//! прозрачные освещаемые -#define MTLTYPE_LAYER_TRANSPARENT_LIGHT 1.0f - -//!@} - -//! тип модели материала -enum MTLTYPE_MODEL -{ - //! статическая геометрия - MTLTYPE_MODEL_STATIC = 0, - - //! растительность трава - MTLTYPE_MODEL_GRASS, - - //! растительность дерево - MTLTYPE_MODEL_TREE, - - //! анимационная модель - MTLTYPE_MODEL_SKIN, - - //! значение по умолчанию - MTLTYPE_MODEL_DEFAULT = MTLTYPE_MODEL_STATIC -}; - -//! физический тип материала -enum MTLTYPE_PHYSIC -{ - MTLTYPE_PHYSIC_CONCRETE = 0, //!< бетон - - //! значение по умолчанию - MTLTYPE_PHYSIC_DEFAULT = MTLTYPE_PHYSIC_CONCRETE, - - //! металл - MTLTYPE_PHYSIC_METAL, - - //! стекло - MTLTYPE_PHYSIC_GLASS, - - //! пластик - MTLTYPE_PHYSIC_PLASTIC, - - //! дерево - MTLTYPE_PHYSIC_TREE, - - //! плоть - MTLTYPE_PHYSIC_FLESH, - - //! земля/песок - MTLTYPE_PHYSIC_GROUD_SAND, - - //! вода - MTLTYPE_PHYSIC_WATER, - - //! листва/трава - MTLTYPE_PHYSIC_LEAF_GRASS, - - //! количество типов - MPT_COUNT -}; - -//! данные отправляемые в шейдеры -enum MTL_SHADERSTD -{ - //! мировая матрица (трансформации модели), world - MTL_SHADERSTD_MATRIX_WORLD = 0, - - //! матрица вида, view - MTL_SHADERSTD_MATRIX_VIEW, - - //! матрица проекции, projection - MTL_SHADERSTD_MATRIX_PROJECTION, - - //! world * view - MTL_SHADERSTD_MATRIX_WORLDVIEW, - - //! world * view * projection - MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ, - - //! позиция камеры/наблюдателя - MTL_SHADERSTD_CAMPOS, - - //! данные о времени float2(CountTimeRender,TimeDelta) - MTL_SHADERSTD_TIMEDELTA, - - //! размеры окна рендера - MTL_SHADERSTD_WINSIZE, - - //! пользовательские данные (float4) - MTL_SHADERSTD_USERDATA -}; - -/*! \name Загрузка/сохранение - \note Файл загрузки/сохранения представлен простым конфигурационным файлом (ini) который можно обрабатывать посредством #ISXLConfig - \todo Расписать организацию конфигурационного файла загрузки/сохранения для материала -@{*/ - -/*! загрузка материала, возвращает уникальный идентификатора материала, - \note все материалы оборачиваются в специальную структуру, поэтому дубликатов среди идентификаторов материалов нет - \note любой повторно загружаемый материал не загружается, а лишь дублирует обертку, со ссылкой на внутренности оберкти - */ -SX_LIB_API ID SML_MtlLoad( - const char *szName, //!< имя_материала.расширение - MTLTYPE_MODEL mtl_type = MTLTYPE_MODEL_STATIC //!< тип модели материала на случай если материал не будет загружен/найден - ); - -//! перезагрузка материала -SX_LIB_API void SML_MtlReloadMaterial( - ID id, //!< идентификатор материала - const char *szName = 0 //!< на случай замены существующего материала другим - ); - -/*! сохранить материал по id - \note Сохранение происходит по отноительному пути в директория/директория_имяфайла.mtl -*/ -SX_LIB_API void SML_MtlSave(ID id); - -//!@} - -/*! очитска, удаляет все загруженные материалы (но место в массиве под них остается), все стандартные остаются - \warning Отражения не удаляются а помещаются в очередь удаления, так как могут сожеражть в себе идентификаторы, которые необходимы очистить, -для полной очистки необходимо вызывать функцию #SML_MtlDelRefClear. Однако во избежания утечек памяти необходимо очистить идентификаторы, для их получения вызыва функцию #SML_MtlDelRefGetIDArr -*/ -SX_LIB_API void SML_MtlClear( - bool isClearRefDel //!< очищать ли очередь удаления отражений, на тот случай если идентификаторы в отражениях больше не действительны - ); - -//! возвращает общее количество материалов -SX_LIB_API long SML_MtlGetCount(); - -//! возвращает тип модели материала по id -SX_LIB_API MTLTYPE_MODEL SML_MtlGetTypeModel(ID id); - -//! возвращает сорт материала по id -SX_LIB_API UINT SML_MtlGetSort(ID id); - -/*! установка типа модели материала по id - \warning меняется только внутренний флаг (определение)!!! все остальное для данного типа надо загружать вручную, сделано для больших возможностей построения материалов -*/ -SX_LIB_API void SML_MtlSetTypeModel(ID id, MTLTYPE_MODEL type_model); - -//! установка параметров материала по id, вызывается перед DIP -SX_LIB_API void SML_MtlRender( - ID id, //!< идентификатор материала - const float4x4 *pWorld //!< указатель на мировую матрицу модели, либо 0 - тогда будет принята единичная матрица - ); - -//! стандартная отрисовка материала, используются стандартные шейдеры, нужно для теней, отражений и прочего -SX_LIB_API void SML_MtlRenderStd( - MTLTYPE_MODEL type, //!< тип материала из MtlTypeModel - const float4x4 *pWorld, //!< мировая матрица трансформации, либо 0 и будет применена единичная матрица - ID idSlot, //!< текстурный слот в который установить текстуру - ID idMtl //!< идентификатор материала из которого будет браться текстура - ); - -//! установка параметров материала для рендера источника света -SX_LIB_API void SML_MtlRenderLight( - const float4_t *pColor, //!< rgb - цвет, w зарезервирован - const float4x4 *pWorld //!< аналогично #SML_MtlRender - ); - -//! установить текстуру из материала id в текстурный слот slot -SX_LIB_API void SML_MtlSetMainTexture(ID idSlot, ID id); - - -//! установка физического типа материала -SX_LIB_API void SML_MtlSetPhysicMaterial(ID id, MTLTYPE_PHYSIC type); - -//! возвращает текущий тип физического материала -SX_LIB_API MTLTYPE_PHYSIC SML_MtlGetPhysicMaterial(ID id); - -//! возвращает id стандартного материала для определенной модели материалов указанной в #MtlTypeModel -SX_LIB_API ID SML_MtlGetStdMtl(MTLTYPE_MODEL type_model); - -/*! \name Управление полупрозрачными поверхностями -Каждый выводимый пиксель помечается номером поверхности к которой он относится - - 0 - пусто - - 1 - непрозрачная геометрия - - все что больше 1 значит полупрозрачная геометрия - \note Если инкремент установлен то отрисовка каждого материала будет инкрементировать внутренний счетчик, присваивая каждому пикселю поверхности идентификатор поверхности. - \note На данный момент максимальное значение полупрозрачных поверхностей может быть только 255 (8 бит) -@{*/ - -/*! установка инкремента идентификатора поверхностей - \note К примеру для диференциации (разделения) пикселей при смешивании всех слоев изображения, -без разделения по принадлжености к определнной поверхности будет трудно/невозможно (пока выхода нет) корректно смешать все слои -*/ -SX_LIB_API void SML_MtlSetIsIncrCountSurf(bool bf); - -//! установлен ли инкремент поверхностей -SX_LIB_API bool SML_MtlGetIsIncrCountSurf(); - -//! обнуление идентификатора отрисованных поверхностей (к примеру при новом кадре) -SX_LIB_API void SML_MtlNullingCurrCountSurf(); - -//! текущее количество отрисованных полупрозрачных поверхностей -SX_LIB_API int SML_MtlGetCurrCountSurf(); - -//! установить текущее количество отрисованных полупрозрачных поверхностей -SX_LIB_API void SML_MtlSetCurrCountSurf(int iCount); - -/*! принудительное включение альфа теста (isat - true - включить, false - выключить) при устновке параметров материала, -к примеру для рендера полупрозрачных поверхностей, чтобы отсечь (условно) полностью прозрачные пиксели -*/ -SX_LIB_API void SML_MtlSetForceblyAlphaTest(bool isEnable); - -//! включен ли принудительный альфа тест -SX_LIB_API bool SML_MtlGetForceblyAlphaTest(); - -//!@} - -/*! \defgroup sxmtllight_mtl_reflect Отражения - \ingroup sxmtllight_mtl - \note Поддерживается 2 вида отражений: - - плоские - - объемные/кубические -@{*/ -//{{ - -//! записать в отражения идентификатор (idArr) для определнной стороны куба/сплита (iCube), соотнести его с идентификатором сущности (idOwner) -SX_LIB_API void SML_MtlRefSetIDArr( - ID id, //!< идентификатор материала - ID idOwner, //!< идентификатор сущности для которой записываем (геометрия, растительность и прочее) - int iCube, //!< условно - сторона куба/сплита для которой записываем - ID idArr //!< идентификатор который надо записать - ); - -//! возвращает идентификатор который был записан для сущности (idOwner) для стороны куба/сплита (iCube), если вообще записывался, если не записывался то <0 -SX_LIB_API ID SML_MtlRefGetIDArr( - ID id, //!< идентификатор материала - ID idOwner, //!< идентификатор сущности для которой было записывано (геометрия, растительность и прочее) - int iCube //!< условно - сторона куба/сплита для которой было записывано - ); - -/*! \name Управление удаленными отражениями -@{*/ - -//! возвращает количество удаленных материалов с отражениями -SX_LIB_API int SML_MtlDelRefGetCount(); - -//! возвращает идентификатор который был записан для сущности (inid) для стороны куба/сплита (cube) -SX_LIB_API ID SML_MtlDelRefGetIDArr( - ID idKey, //!< порядковый номер удаленного материала с отражением - ID idOwner, //!< идентификатор сущности для которой было записано (геометрия, растительность и прочее) - int iCube //!< условно - сторона куба/сплита для которой было записывано - ); - -//! очистка массива удаленных материалов с отражениями -SX_LIB_API void SML_MtlDelRefClear(); - -//!@} - -//! обработка статистики рендера для текущего матриала с отражением -SX_LIB_API bool SML_MtlRefUpdateCountUpdate( - ID id, //!< идентификатора материала - const float3_t *pViewPos //!< позиция наблюдателя, viewpos == 0 вернет false - ); - -/*! обнуление статистикки рендера для данного материала с отражением, -полезно в случаях каких-либо изменений, чтобы эти изменения были видны и в отражениях (актуально для статических отражений) -*/ -SX_LIB_API void SML_MtlRefNullingCountUpdate(ID id); - -//! установка экстремумов материала -SX_LIB_API void SML_MtlRefSetMinMax(ID id, const float3_t *pMin, const float3_t *pMax); - -//! возвращает фрустум отражения, cube - сторона куба -SX_LIB_API const IFrustum* SML_MtlRefGetfrustum( - ID id, //!< идентификатора материала - int iCube //!< сторона куба, если отражение плоское то необходимо указать в cube передать 0, иначе вернет NULL - ); - -SX_LIB_API bool SML_MtlRefIsAllowedRender(ID id); //!< разрешен ли рендер отражений для данного материала в текущий момент - -/*! \name Рендер плоского отражения - \note Перед началом рендера плоских отражений необходимо в регистры матриц в #G_RI_MATRIX_VIEW поместить матрицу вида наблюдателя - \note Порядок рендера: - \code - SML_MtlRefPreRenderPlane(id, plane); - //код рендера всего того что необходимо поместить в текстуру отражений - SML_MtlRefPostRenderPlane(id); - \endcode -@{*/ - -//! первоначальные настройки данных для генерации отражения -SX_LIB_API void SML_MtlRefPreRenderPlane( - ID id, //!< идентификатор материала - D3DXPLANE *pPlane //!< плоскость относительно которой будет считаться отражение - ); - -//! завершающие операции -SX_LIB_API void SML_MtlRefPostRenderPlane(ID id); - -//! возвращает текстуру с плоским отражением (если оно есть, иначе 0) -SX_LIB_API IDirect3DTexture9* SML_MtlRefGetTexPlane(ID id); - -//!@} - -/*! \name Рендер объемного (кубического) отражения - \note Порядок рендера: - \code - SML_MtlRefCubeBeginRender(id, center); - SML_MtlRefCubePreRender(id, cube, world); - //код рендера всего того что необходимо поместить в текстуру отражений - SML_MtlRefCubePostRender(id, cube); - SML_MtlRefCubeEndRender(id, viewpos); - \endcode -@{*/ - -//! установка общих настроек -SX_LIB_API void SML_MtlRefCubeBeginRender( - ID id, //!< идентификатор материала - const float3_t *pCenter //!< центр (позиция) подгруппы модели - откуда будет рендер отражений - ); - -//! установка частных настроек для стороны куба (cube) -SX_LIB_API void SML_MtlRefCubePreRender( - ID id, //!< идентификатор материала - int iCube, //!< сторона куба [0,5] - const float4x4 *pWorld //!< мировая матрица модели - ); - -//! завершающие частные моменты для стороны куба -SX_LIB_API void SML_MtlRefCubePostRender(ID id, int iCube); - -/*! завершающие общие моменты - \note если viewpos == 0 обновления статисктики рендера для текущего материала с отражением не произойдет, -и дабы рационально обрабатывать и статические и динамические отражения необходимо до следующего рендера отражений вызвать SML_MtlRefUpdateCountUpdate -*/ -SX_LIB_API void SML_MtlRefCubeEndRender( - ID id, //!< идентификатор материала - const float3_t *pViewPos //!< позиция наблюдателя, необходимо для обработки разрешения на следующий рендер - ); - -//! возвращает cube текстуру отражением (если оно есть, иначе 0) -SX_LIB_API IDirect3DCubeTexture9* SML_MtlRefCubeGetTex(ID id); - -//!@} - -//!@} sxmtllight_mtl_reflect - - -/*! \defgroup sxmtllight_mtl_propslayer Cвойства поверхности - \ingroup sxmtllight_mtl -@{*/ - -//! установка основной текстуры (загрузка текстуры по имени) -SX_LIB_API void SML_MtlSetTexture(ID id, const char *szPathTex); - -//! в name записывает имя текстуры -SX_LIB_API void SML_MtlGetTexture(ID id, char *szName); - -//! возвращает id текстуры материала -SX_LIB_API ID SML_MtlGetTextureID(ID id); - - -/*! \name Шейдеры для рендера материала - \warning В текущей версии все шейдеры загружаются в версии 3.0 и требуют в качестве старта указывать функцию main - \warning Рекомендуется устанавливать и вершинный и пиксельный шейдеры, так как во врем тестов одно из устройств требовало наличия обоих шейдеров либо отсутствия обоих - \note В аргументах path_vs/path_ps указывается только имя шейдера с расширением, есесно возвращается тоже самое -@{*/ - -//! установка вершинного шейдера -SX_LIB_API void SML_MtlSetVS(ID id, const char *szPathVS); - -//! в name записывает имя текущего вершинного шейдера -SX_LIB_API void SML_MtlGetVS(ID id, char *szName); - -//! установка пиксельного шейдера -SX_LIB_API void SML_MtlSetPS(ID id, const char *szPathPS); - -//! в name записывает имя текущего пикельного шейдера -SX_LIB_API void SML_MtlGetPS(ID id, char *szName); - -//!@} - -//! возвращает коэффициент пробиваемости [0, ], чем больше тем сложнее пробить -SX_LIB_API float SML_MtlGetDurability(ID id); - -//! устанавливает коэффициент пробиваемости [0, ], чем больше тем сложнее пробить -SX_LIB_API void SML_MtlSetDurability(ID id, float fDurability); - - -//! возвращает шанс пробиваемости [0 - пуля летит насквозь, 1 - пуля ударяется] -SX_LIB_API float SML_MtlGetHitChance(ID id); - -//! устанавливает шанс пробиваемости [0 - пуля летит насквозь, 1 - пуля ударяется] -SX_LIB_API void SML_MtlSetHitChance(ID id, float fHitChance); - - -//! возвращает плотность материала кг/м3 -SX_LIB_API float SML_MtlGetDensity(ID id); - -//! устанавливает плотность материала кг/м3 -SX_LIB_API void SML_MtlSetDensity(ID id, float fDensity); - - -//! используется ли альфа тест для материала -SX_LIB_API bool SML_MtlGetUsingAlphaTest(ID id); - -//! установка использования альфа теста -SX_LIB_API void SML_MtlSetUsingAlphaTest(ID id, bool isUsing); - -/*! освещение материала id - \note если материал не освещается то будет выведен в цвете накладываемым материалом -*/ -SX_LIB_API void SML_MtlSetLighting(ID id, bool isLighting); - -//! освещается ли материал -SX_LIB_API bool SML_MtlGetLighting(ID id); - -/*! \name Параметры освещения. - \note Для более точной/тонкой настройки освещения материала рекомендуется использовать текстуру с параметрами освещения -(к прмиеру когда в одной поверхности разные материалы, к примеру дерево, метал и камень, то в текстуре можно указать параметры освещения для каждого пикселя), -однако если текстуры нет то будут использованы установленные парметры освещения для всей поверхности -@{*/ - -//! установка использования текстуры с параметрами освещения -SX_LIB_API void SML_MtlSetIsTextureLighting(ID id, bool isTexLighting); - -//! используется ли текстура с параметрами для освещения -SX_LIB_API bool SML_MtlGetIsTextureLighting(ID id); - - -//! загрузка текстуры с парамтерами освещения -SX_LIB_API void SML_MtlSetTextureLighting(ID id, const char *szPathTex); - -//! в path_tex записывает имя текстуры с параметрами освещения -SX_LIB_API void SML_MtlGetTextureLighting(ID id, char *szPathTex); - - -//! установка шероховатости (0-1) -SX_LIB_API void SML_MtlSetRoughness(ID id, float fRoughness); - -//! возвращает текущее значение шероховатости поверхности -SX_LIB_API float SML_MtlGetRoughness(ID id); - - -//! установка просвечиваемости (толщины для графики (0, 1)), 0 - не принимает затенение, 1 - полностью принимает затенение -SX_LIB_API void SML_MtlSetThickness(ID id, float fThickness); - -//! возвращает просвечиваемости (толщины для графики (0, 1)), 0 - не принимает затенение, 1 - полностью принимает затенение -SX_LIB_API float SML_MtlGetThickness(ID id); - -//! установка отражательной способности поверхности (0-1) -SX_LIB_API void SML_MtlSetF0(ID id, float fF0); - -//! возвращает текущее значение отражательной способности поверхности -SX_LIB_API float SML_MtlGetF0(ID id); - -//!@} - -/*! \name Полупрозрачность -Под полупрозрачными материалами следует понимать такие материалы, прозрачность которых в среднем находится в пределах [0.5, 1) и минимальный процент полупрозрачного периметра 50% -@{*/ - -//! установка свойства полупрозрачности -SX_LIB_API void SML_MtlSetTransparency(ID id, bool isTransparent); - -//! возвращает текущее значение свойства полупрозрачности для материала -SX_LIB_API bool SML_MtlGetTransparency(ID id); - -//!@} - -/*! \name Отражения окружения, типы из #MtlTypeReflect -@{*/ - -//! установка типа отражений -SX_LIB_API void SML_MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type); - -//! возвращает текущий тип отражений для материала -SX_LIB_API MTLTYPE_REFLECT SML_MtlGetTypeReflection(ID id); - -//!@} - -/*! \name Детальность и микрорельеф -Поверхность может содержать до 4 детальных текстур и до 4 текстур с микрорельефом. -Данные для определения наложения текстур (детальных и микрорельефных) указываются в маске - -на каждый канал текстуры маски по одной детальной и микрорельефной текстуре, -то есть канал маски определет связанные между собой и детальную и микрорельефную текстуры - \note В аргументах channel - RGBA - 0,1,2,3 -@{*/ - -//! загрузка маски наложения -SX_LIB_API void SML_MtlSetMaskTex(ID id, const char *szPathTex); - -//! в path_tex записывает текущее имя маски наложения -SX_LIB_API void SML_MtlGetMaskTex(ID id, char *szPathTex); - -//! загрузка текстуры микрорельефа, на каждый канал -SX_LIB_API void SML_MtlSetMRTex( - ID id, //!< идентификатор материала - int iChannel, //!< номер канала RGBA - 0,1,2,3 - const char *szPathTex //!< имя текстуры с расширением - ); - -//! в path_tex запишет текущее имя текстуры микрорельефа для канала channel -SX_LIB_API void SML_MtlGetMRTex(ID id, int iChannel, char *szPathTex); - -//! загрузка детальной текстуры, на каждый канал -SX_LIB_API void SML_MtlSetDTex( - ID id, //!< идентификатор материала - int iChannel, //!< номер канала RGBA - 0,1,2,3 - const char *szPathTex //!< имя текстуры с расширением - ); - -//! в path_tex запишет текущее имя детальной текстуры для канала channel -SX_LIB_API void SML_MtlGetDTex(ID id, int iChannel, char *szPathTex); - -//!@} - -/*! \name Стандартные параметры для отправки в шейдер (в вершинный и пиксельный раздельно), данные из #MtlTransShaderStd -@{*/ - -//! отправка стадартных данных в вершинный шейдер -SX_LIB_API void SML_MtlSetStdVS( - ID id, //!< идентификатор материала - MTL_SHADERSTD type, //!< тип значения которое нужно отправить, одно из значений #MtlTransShaderStd - bool isSend //!< true - отправлять, false - не отправлять - ); - -//! установлена ли отпрвка значения type в вершинный шейдер -SX_LIB_API bool SML_MtlGetStdVS(ID id, MTL_SHADERSTD type); - -//! отправка стадартных данных в пиксельный шейдер -SX_LIB_API void SML_MtlSetStdPS( - ID id, //!< идентификатор материала - MTL_SHADERSTD type, //!< тип значения которое нужно отправить, одно из значений #MtlTransShaderStd - bool isSend //!< true - отправлять, false - не отправлять - ); - -//! установлена ли отпрвка значения type в пиксельный шейдер -SX_LIB_API bool SML_MtlGetStdPS(ID id, MTL_SHADERSTD type); - -//!@} - -/*! \name Дополнительные пользовательские данные в виде float4 (предел [0-1] для стандарта, иное вне стандарта, но допустимо) - \note Данные для вершинного и пиксельного шейдера раздельны. Отправляется float4. -Однако данные и из пиксельного могут быть отправленны в вершинный и наоборот. -В итоге в шейдере может быть 2 float4 пользовательских вектора с данными. -Но если вектор определен для пиксельного то он все-равно будет отправлен в пиксельный шейдер, даже если и придназначалася для вершинного. - \note В аргументах component - xyzw - 0,1,2,3 -@{*/ - -//! установка значения компоненты вектора для вершинного шейдера -SX_LIB_API void SML_MtlSetUserDataVS( - ID id, //!< идентификатор материала - int iComponent, //!< компонента вектора xyzw - 0,1,2,3 - float fValue //!< значение компоненты - ); - -//! возвращает значение компоненты вектора, который отправляется в вершинный шейдер -SX_LIB_API float SML_MtlGetUserDataVS(ID id, int iComponent); - -//! установка отправки float4 вектора, предназначенного для вершинного шейдера, в пиксельный шейдер -SX_LIB_API void SML_MtlSetUserDataVS_InPS(ID id, bool isSendPs); - -//! отправляется ли float4 вектор, предназначенный для вершинного шейдера, в пиксельный шейдер -SX_LIB_API bool SML_MtlGetUserDataVS_InPS(ID id); - - -//! установка значения компоненты вектора для пиксельного шейдера -SX_LIB_API void SML_MtlSetUserDataPS( - ID id, //!< идентификатор материала - int iComponent, //!< компонента вектора xyzw - 0,1,2,3 - float fValue //!< значение компоненты - ); - -//! возвращает значение компоненты вектора, который отправляется в пиксельный шейдер -SX_LIB_API float SML_MtlGetUserDataPS(ID id, int iComponent); - -//! установка отправки float4 вектора, предназначенного для пиксельного шейдера, в вершинный шейдер -SX_LIB_API void SML_MtlSetUserDataPS_InVS(ID id, bool isSendVs); - -//! отправляется ли float4 вектор, предназначенный для пиксельного шейдера, в вершинный шейдер -SX_LIB_API bool SML_MtlGetUserDataPS_InVS(ID id); - -//!@} - -//!@} sxmtllight_mtl_propslayer - -//!@} sxmtllight_mtl - -#endif - -//!@} sxmtllight diff --git a/source/mtllight/material.cpp b/source/mtrl/material.cpp similarity index 99% rename from source/mtllight/material.cpp rename to source/mtrl/material.cpp index daa847424ffdbab06f891e37712142b658e4a54d..1a6db03f16623fb995e3a91743b67f4a03a4608d 100644 --- a/source/mtllight/material.cpp +++ b/source/mtrl/material.cpp @@ -1949,7 +1949,7 @@ void CMaterials::render(ID id, const float4x4 *pWorld) MLSet::DXDevice->SetTexture(MTL_TEX_R_REFLECTION, m_aUnitMtrls[id]->m_pReflect->getRefCubeTex()); } - MLSet::DXDevice->SetTexture(MTL_TEX_R_CURR_DEPTH, SGCore_RTGetTexture(MLSet::IDsRenderTargets::DepthScene0)); + MLSet::DXDevice->SetTexture(MTL_TEX_R_CURR_DEPTH, SGCore_GbufferGetRT(DS_RT_DEPTH0)); //если есть рефаркци¤, а она идет вторым проходом, то отправл¤ем, иначе посылаем 0 /*if (pMtrl->m_oLightParam.m_type_transparency) diff --git a/source/mtllight/material.h b/source/mtrl/material.h similarity index 100% rename from source/mtllight/material.h rename to source/mtrl/material.h diff --git a/source/mtrl/ml_data.cpp b/source/mtrl/ml_data.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7da1be985b41251e03cb4fa3f1109fadaafa0e86 --- /dev/null +++ b/source/mtrl/ml_data.cpp @@ -0,0 +1,116 @@ + +/*********************************************************** +Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#include "ml_data.h" + +namespace MLSet +{ + void MLInit(); + IDirect3DDevice9* DXDevice = 0; + + + float2_t SizeTexReflection = float2_t(MTL_REF_TEX_SIZE, MTL_REF_TEX_SIZE); + + //ориентаци¤ и верхний вектор дл¤ рендера в кубическую текстуру + float3 OrientedCube[6] = { float3(1, 0, 0), float3(-1, 0, 0), float3(0, 1, 0), float3(0, -1, 0), float3(0, 0, 1), float3(0, 0, -1) }; + float3 UpVectorsCube[6] = { float3(0, 1, 0), float3(0, 1, 0), float3(0, 0, -1), float3(0, 0, 1), float3(0, 1, 0), float3(0, 1, 0) }; + + float4x4 RefMProjPlane; + float4x4 RefMProjCube; + + namespace IDsShaders + { + namespace VS + { + ID ResPosDepth; + + ID ScreenOut; + + ID StdGeom; + ID StdTree; + ID StdGrass; + ID StdSkin; + }; + + namespace PS + { + ID ScreenOut; + + ID StdGeom; + ID StdGeomCP; + ID StdGreen; + ID StdGreenCP; + ID StdSkin; + ID StdSkinCP; + }; + }; + + namespace IDsTexs + { + ID Tex_NoiseTex; + }; +}; + +void MLSet::MLInit() +{ + MLSet::DXDevice = SGCore_GetDXDevice(); + + const int *r_win_width = GET_PCVAR_INT("r_win_width"); + const int *r_win_height = GET_PCVAR_INT("r_win_height"); + + const float *r_default_fov = GET_PCVAR_FLOAT("r_default_fov"); + + //MLSet::IDsTexs::Tex_NoiseTex = SGCore_LoadTexAddName("noise_rottex.dds", LOAD_TEXTURE_TYPE_CONST); + + D3DLOCKED_RECT LockedRect; + uint32_t* tmpOldColor; + IDirect3DTexture9 *pRnsSampler; + MLSet::DXDevice->CreateTexture(4, 4, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pRnsSampler, NULL); + + uint32_t aRndColors[16];// = D3DCOLOR_ARGB(0, 250, 2, 255); + + for (int i = 0; i < 16; ++i) + aRndColors[i] = D3DCOLOR_ARGB(255, rand() % 255, rand() % 255, rand() % 255); + + pRnsSampler->LockRect(0, &LockedRect, 0, 0); + memcpy(LockedRect.pBits, aRndColors, sizeof(uint32_t)); + pRnsSampler->UnlockRect(0); + + //SGCore_LoadTexLoadTextures(); + MLSet::IDsTexs::Tex_NoiseTex = SGCore_LoadTexCreate("noise_rottex__", pRnsSampler); + + + MLSet::IDsShaders::VS::ResPosDepth = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_res_pos.vs", "pp_quad_render_res_pos.vs", SHADER_CHECKDOUBLE_PATH); + + MLSet::IDsShaders::VS::ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_quad_render.vs", "pp_quad_render.vs", SHADER_CHECKDOUBLE_PATH); + MLSet::IDsShaders::PS::ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_quad_render.ps", "pp_quad_render.ps", SHADER_CHECKDOUBLE_PATH); + + + MLSet::IDsShaders::VS::StdGeom = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "stdr_geom.vs", "stdr_geom.vs", SHADER_CHECKDOUBLE_NAME); + MLSet::IDsShaders::PS::StdGeom = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "stdr_geom.ps", "stdr_geom.ps", SHADER_CHECKDOUBLE_NAME); + + D3DXMACRO Defines_CP[] = { { "_CLIP_PLANE_", "" }, { 0, 0 } }; + MLSet::IDsShaders::PS::StdGeomCP = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "stdr_geom.ps", "stdr_geom_cp.ps", SHADER_CHECKDOUBLE_NAME, Defines_CP); + + D3DXMACRO Defines_GRASS[] = { { "_GRASS_", "" }, { 0, 0 } }; + MLSet::IDsShaders::VS::StdGrass = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "stdr_green.vs", "stdr_grass.vs", SHADER_CHECKDOUBLE_NAME, Defines_GRASS); + MLSet::IDsShaders::VS::StdTree = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "stdr_green.vs", "stdr_tree.vs", SHADER_CHECKDOUBLE_NAME); + + MLSet::IDsShaders::PS::StdGreen = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "stdr_green.ps", "stdr_green.ps", SHADER_CHECKDOUBLE_NAME); + MLSet::IDsShaders::PS::StdGreenCP = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "stdr_green.ps", "stdr_green_cp.ps", SHADER_CHECKDOUBLE_NAME, Defines_CP); + + + MLSet::IDsShaders::VS::StdSkin = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "stdr_skin.vs", "stdr_skin.vs", SHADER_CHECKDOUBLE_NAME); + MLSet::IDsShaders::PS::StdSkin = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "stdr_skin.ps", "stdr_skin.ps", SHADER_CHECKDOUBLE_NAME); + + MLSet::IDsShaders::PS::StdSkinCP = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "stdr_skin.ps", "stdr_skin_cp.ps", SHADER_CHECKDOUBLE_NAME, Defines_CP); + + + + + MLSet::RefMProjPlane = SMMatrixPerspectiveFovLH(*r_default_fov, float(*r_win_width) / float(*r_win_height), MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); + MLSet::RefMProjCube = SMMatrixPerspectiveFovLH(SM_PI * 0.5f, 1, MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); +} \ No newline at end of file diff --git a/source/mtrl/ml_data.h b/source/mtrl/ml_data.h new file mode 100644 index 0000000000000000000000000000000000000000..c9dc1cabb74a9f53f0ad74f9d2154e0507880c1b --- /dev/null +++ b/source/mtrl/ml_data.h @@ -0,0 +1,72 @@ + +/*********************************************************** +Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#ifndef __ML_DATA_H +#define __ML_DATA_H + +#include + +#define SM_D3D_CONVERSIONS +#include +#include + +#include + +#include "sxmtrl.h" + +namespace MLSet +{ + void MLInit(); + + extern IDirect3DDevice9* DXDevice; + + extern float2_t SizeTexReflection; + + //ориентаци¤ и верхний вектор дл¤ рендера в кубическую текстуру + extern float3 OrientedCube[6]; + extern float3 UpVectorsCube[6]; + + extern float4x4 RefMProjPlane; + extern float4x4 RefMProjCube; + + namespace IDsShaders + { + namespace VS + { + extern ID ResPosDepth; + + extern ID ScreenOut; + + extern ID StdGeom; + extern ID StdTree; + extern ID StdGrass; + extern ID StdSkin; + }; + + namespace PS + { + extern ID CalcAdaptedLum; + extern ID SampleLumInit; + extern ID SampleLumIterative; + + extern ID ScreenOut; + + extern ID StdGeom; + extern ID StdGeomCP; + extern ID StdGreen; + extern ID StdGreenCP; + extern ID StdSkin; + extern ID StdSkinCP; + }; + }; + + namespace IDsTexs + { + extern ID Tex_NoiseTex; + }; +}; + +#endif \ No newline at end of file diff --git a/source/mtllight/reflection.cpp b/source/mtrl/reflection.cpp similarity index 100% rename from source/mtllight/reflection.cpp rename to source/mtrl/reflection.cpp diff --git a/source/mtllight/reflection.h b/source/mtrl/reflection.h similarity index 99% rename from source/mtllight/reflection.h rename to source/mtrl/reflection.h index f4bf34729c9f5db41e4e0044299cdc904f9dfa05..916b83fc79a9ef1a5bcf6f46d1c05d6dfc991664 100644 --- a/source/mtllight/reflection.h +++ b/source/mtrl/reflection.h @@ -14,7 +14,7 @@ See the license in LICENSE #include #include -#include "sxmtllight.h" +#include "sxmtrl.h" #include "ml_data.h" /*! класс отражений, возможны плоские отражения и кубические diff --git a/source/mtrl/sxmtrl.cpp b/source/mtrl/sxmtrl.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a6577294691e7d00db12d1bfc049343f71f1e961 --- /dev/null +++ b/source/mtrl/sxmtrl.cpp @@ -0,0 +1,650 @@ + +/*********************************************************** +Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#define SXMATERIAL_LIGTH_VERSION 1 + +#include "sxmtrl.h" +#include "ml_data.h" + +#include "material.h" + +#if !defined(DEF_STD_REPORT) +#define DEF_STD_REPORT +report_func g_fnReportf = DefReport; +#endif + +CMaterials* ArrMaterials = 0; + +#define ML_PRECOND(retval) if(!ArrMaterials){LibReport(-1, "%s - sxmtrl is not init", GEN_MSG_LOCATION); return retval;} + +//########################################################################## + +SX_LIB_API long SMtrl_0GetVersion() +{ + return SXMATERIAL_LIGTH_VERSION; +} + +SX_LIB_API void SMtrl_Dbg_Set(report_func rf) +{ + g_fnReportf = rf; +} + +SX_LIB_API void SMtrl_0Create(const char *szName, bool isUnic) +{ + if (szName && strlen(szName) > 1) + { + if (isUnic) + { + HANDLE hMutex = CreateMutex(NULL, FALSE, szName); + if (GetLastError() == ERROR_ALREADY_EXISTS) + { + CloseHandle(hMutex); + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - none unic name", GEN_MSG_LOCATION); + } + else + { + MLSet::MLInit(); + ArrMaterials = new CMaterials(); + } + } + else + { + MLSet::MLInit(); + ArrMaterials = new CMaterials(); + } + } + else + LibReport(REPORT_MSG_LEVEL_ERROR, "%s - not init argument [name]", GEN_MSG_LOCATION); +} + +SX_LIB_API void SMtrl_AKill() +{ + mem_delete(ArrMaterials); +} + +SX_LIB_API void SMtrl_OnLostDevice() +{ + ML_PRECOND(_VOID); + ArrMaterials->onLostDevice(); +} + +SX_LIB_API void SMtrl_OnResetDevice() +{ + ML_PRECOND(_VOID); + + ArrMaterials->onResetDevice(); + + //MLSet::rt_id::HowAdaptedLum = 0; +} + +SX_LIB_API void SMtrl_Update(DWORD timeDelta) +{ + static const int *r_win_width = GET_PCVAR_INT("r_win_width"); + static const int *r_win_height = GET_PCVAR_INT("r_win_height"); + + static const float *r_default_fov = GET_PCVAR_FLOAT("r_default_fov"); + + if (ArrMaterials) + ArrMaterials->update(timeDelta); + + MLSet::RefMProjPlane = SMMatrixPerspectiveFovLH(*r_default_fov, float(*r_win_width) / float(*r_win_height), MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); + MLSet::RefMProjCube = SMMatrixPerspectiveFovLH(SM_PI * 0.5f, 1, MTl_REF_PROJ_NEAR, MTl_REF_PROJ_FAR); +} + +//############################################################################# + +SX_LIB_API ID SMtrl_MtlLoad(const char *szName, MTLTYPE_MODEL mtl_type) +{ + ML_PRECOND(-1); + + return ArrMaterials->mtlLoad(szName, mtl_type); +} + +SX_LIB_API void SMtrl_MtlSave(ID id) +{ + ML_PRECOND(_VOID); + + ArrMaterials->mtlSave(id); +} + +SX_LIB_API MTLTYPE_MODEL SMtrl_MtlGetTypeModel(ID id) +{ + ML_PRECOND(MTLTYPE_MODEL_STATIC); + + return ArrMaterials->getTypeModel(id); +} + +SX_LIB_API UINT SMtrl_MtlGetSort(ID id) +{ + ML_PRECOND(0); + + return ArrMaterials->mtlGetSort(id); +} + +SX_LIB_API void SMtrl_MtlSetTypeModel(ID id, MTLTYPE_MODEL type_model) +{ + ML_PRECOND(_VOID); + + ArrMaterials->setTypeModel(id, type_model); +} + +SX_LIB_API long SMtrl_MtlGetCount() +{ + ML_PRECOND(-1); + + return ArrMaterials->getCount(); +} + +SX_LIB_API void SMtrl_MtlRender(ID id, const float4x4 *pWorld) +{ + ML_PRECOND(_VOID); + ArrMaterials->render(id, pWorld); +} + +SX_LIB_API void SMtrl_MtlRenderStd(MTLTYPE_MODEL type, const float4x4 *pWorld, ID idSlot, ID idMtl) +{ + ML_PRECOND(_VOID); + ArrMaterials->renderStd(type, pWorld, idSlot, idMtl); +} + +SX_LIB_API void SMtrl_MtlRenderLight(const float4_t *pColor, const float4x4 *pWorld) +{ + ML_PRECOND(_VOID); + ArrMaterials->renderLight(pColor, pWorld); +} + +SX_LIB_API void SMtrl_MtlSetMainTexture(ID slot, ID id) +{ + ML_PRECOND(_VOID); + ArrMaterials->setMainTexture(slot, id); +} + +SX_LIB_API void SMtrl_MtlSetIsIncrCountSurf(bool bf) +{ + ML_PRECOND(_VOID); + ArrMaterials->setIsIncrCountSurf(bf); +} + +SX_LIB_API bool SMtrl_MtlGetIsIncrCountSurf() +{ + ML_PRECOND(false); + return ArrMaterials->getIsIncrCountSurf(); +} + +SX_LIB_API void SMtrl_MtlNullingCurrCountSurf() +{ + ML_PRECOND(_VOID); + ArrMaterials->nullingCurrCountSurf(); +} + +SX_LIB_API int SMtrl_MtlGetCurrCountSurf() +{ + ML_PRECOND(-1); + return ArrMaterials->getCurrCountSurf(); +} + +SX_LIB_API void SMtrl_MtlSetCurrCountSurf(int iCount) +{ + ML_PRECOND(_VOID); + ArrMaterials->setCurrCountSurf(iCount); +} + +SX_LIB_API void SMtrl_MtlSetForceblyAlphaTest(bool isAlphaTest) +{ + ML_PRECOND(_VOID); + ArrMaterials->setForceblyAlphaTest(isAlphaTest); +} + +SX_LIB_API bool SMtrl_MtlGetForceblyAlphaTest() +{ + ML_PRECOND(false); + return ArrMaterials->getForceblyAlphaTest(); +} + + +SX_LIB_API ID SMtrl_MtlGetStdMtl(MTLTYPE_MODEL type_model) +{ + ML_PRECOND(-1); + return ArrMaterials->getStdMtl(type_model); +} + + +SX_LIB_API void SMtrl_MtlSetPhysicMaterial(ID id, MTLTYPE_PHYSIC type) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetPhysicMaterial(id, type); +} + +SX_LIB_API MTLTYPE_PHYSIC SMtrl_MtlGetPhysicMaterial(ID id) +{ + ML_PRECOND(MTLTYPE_PHYSIC_DEFAULT); + return ArrMaterials->mtlGetPhysicMaterial(id); +} + +SX_LIB_API bool SMtrl_MtlGetUsingAlphaTest(ID id) +{ + ML_PRECOND(false); + return ArrMaterials->mtlGetUsingAlphaTest(id); +} + +SX_LIB_API void SMtrl_MtlSetUsingAlphaTest(ID id, bool isUsing) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetUsingAlphaTest(id, isUsing); +} + + + +SX_LIB_API void SMtrl_RefSetIDArr(ID id, ID idOwner, int iCube, ID idArr) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefSetIDArr(id, idOwner, iCube, idArr); +} + +SX_LIB_API ID SMtrl_RefGetIDArr(ID id, ID idOwner, int iCube) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlRefGetIDArr(id, idOwner, iCube); +} + +SX_LIB_API int SMtrl_RefDelGetCount() +{ + ML_PRECOND(-1); + return ArrMaterials->delRefCount(); +} + +SX_LIB_API ID SMtrl_RefDelGetIDArr(ID idKey, ID idOwner, int iCube) +{ + ML_PRECOND(-1); + return ArrMaterials->delRefGetIDArr(idKey, idOwner, iCube); +} + +SX_LIB_API void SMtrl_RefDelClear() +{ + ML_PRECOND(_VOID); + ArrMaterials->delRefAllDel(); +} + +SX_LIB_API void SMtrl_RefSetMinMax(ID id, const float3_t *pMin, const float3_t *pMax) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefSetMinMax(id, pMin, pMax); +} + +SX_LIB_API void SMtrl_RefPreRenderPlane(ID id, D3DXPLANE *pPlane) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefPreRenderPlane(id, pPlane); +} + +SX_LIB_API const IFrustum* SMtrl_RefGetfrustum(ID id, int iCube) +{ + ML_PRECOND(0); + return ArrMaterials->mtlRefGetfrustum(id, iCube); +} + +SX_LIB_API bool SMtrl_RefIsAllowedRender(ID id) +{ + ML_PRECOND(false); + return ArrMaterials->mtlRefIsAllowedRender(id); +} + +SX_LIB_API void SMtrl_RefPostRenderPlane(ID id) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefPostRenderPlane(id); +} + +SX_LIB_API IDirect3DTexture9* SMtrl_RefGetTexPlane(ID id) +{ + ML_PRECOND(0); + return ArrMaterials->mtlRefPlaneGetTex(id); +} + + + +SX_LIB_API void SMtrl_RefCubeBeginRender(ID id, const float3_t *pCenter) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefCubeBeginRender(id, pCenter); +} + +SX_LIB_API void SMtrl_RefCubePreRender(ID id, int iCube, const float4x4 *pWorld) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefCubePreRender(id, iCube, pWorld); +} + +SX_LIB_API void SMtrl_RefCubePostRender(ID id, int iCube) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefCubePostRender(id, iCube); +} + +SX_LIB_API void SMtrl_RefCubeEndRender(ID id, const float3_t *pViewPos) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefCubeEndRender(id, pViewPos); +} + +SX_LIB_API bool SMtrl_RefUpdateCountUpdate(ID id, const float3_t *pViewPos) +{ + ML_PRECOND(false); + return ArrMaterials->mtlRefUpdateCountUpdate(id, pViewPos); +} + +SX_LIB_API void SMtrl_RefNullingCountUpdate(ID id) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlRefNullingCountUpdate(id); +} + +SX_LIB_API IDirect3DCubeTexture9* SMtrl_RefCubeGetTex(ID id) +{ + ML_PRECOND(0); + return ArrMaterials->refCubeGetTex(id); +} + +//########################################################################## + +SX_LIB_API void SMtrl_MtlReloadMaterial(ID id, const char *szName) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlReLoad(id, szName); +} + +SX_LIB_API void SMtrl_MtlClear(bool isClearRefDel) +{ + ML_PRECOND(_VOID); + ArrMaterials->clear(isClearRefDel); +} + +SX_LIB_API void SMtrl_MtlSetTexture(ID id, const char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetTexture(id, szTexture); +} + +SX_LIB_API void SMtrl_MtlGetTexture(ID id, char *szName) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlGetTexture(id, szName); +} + +SX_LIB_API ID SMtrl_MtlGetTextureID(ID id) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetTextureID(id); +} + +SX_LIB_API void SMtrl_MtlSetVS(ID id, const char *szPath) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetVS(id, szPath); +} + +SX_LIB_API void SMtrl_MtlGetVS(ID id, char *szName) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlGetVS(id, szName); +} + +SX_LIB_API void SMtrl_MtlSetPS(ID id, const char *szPath) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetPS(id, szPath); +} + +SX_LIB_API void SMtrl_MtlGetPS(ID id, char *szName) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlGetPS(id, szName); +} + +SX_LIB_API float SMtrl_MtlGetDurability(ID id) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetDurability(id); +} + +SX_LIB_API void SMtrl_MtlSetDurability(ID id, float fDurability) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetDurability(id, fDurability); +} + +SX_LIB_API float SMtrl_MtlGetHitChance(ID id) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetHitChance(id); +} + +SX_LIB_API void SMtrl_MtlSetHitChance(ID id, float fHitChance) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetHitChance(id, fHitChance); +} + +SX_LIB_API float SMtrl_MtlGetDensity(ID id) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetDensity(id); +} + +SX_LIB_API void SMtrl_MtlSetDensity(ID id, float fDensity) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetDensity(id, fDensity); +} + +//########################################################################## + +SX_LIB_API void SMtrl_MtlSetLighting(ID id, bool isLighting) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetLighting(id, isLighting); +} + +SX_LIB_API bool SMtrl_MtlGetLighting(ID id) +{ + ML_PRECOND(false); + return ArrMaterials->mtlGetLighting(id); +} + +SX_LIB_API void SMtrl_MtlSetIsTextureLighting(ID id, bool isTexLighting) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetIsTextureLighting(id, isTexLighting); +} + +SX_LIB_API bool SMtrl_MtlGetIsTextureLighting(ID id) +{ + ML_PRECOND(false); + return ArrMaterials->mtlGetIsTextureLighting(id); +} + +SX_LIB_API void SMtrl_MtlSetTextureLighting(ID id, const char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetTextureLighting(id, szTexture); +} + +SX_LIB_API void SMtrl_MtlGetTextureLighting(ID id, char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlGetTextureLighting(id, szTexture); +} + +SX_LIB_API void SMtrl_MtlSetRoughness(ID id, float fRoughness) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetRoughness(id, fRoughness); +} + +SX_LIB_API float SMtrl_MtlGetRoughness(ID id) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetRoughness(id); +} + +SX_LIB_API void SMtrl_MtlSetThickness(ID id, float fThickness) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetThickness(id, fThickness); +} + +SX_LIB_API float SMtrl_MtlGetThickness(ID id) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetThickness(id); +} + +SX_LIB_API void SMtrl_MtlSetF0(ID id, float fF0) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetF0(id, fF0); +} + +SX_LIB_API float SMtrl_MtlGetF0(ID id) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetF0(id); +} + +SX_LIB_API void SMtrl_MtlSetTransparency(ID id, bool isTransparent) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetTransparency(id, isTransparent); +} + +SX_LIB_API bool SMtrl_MtlGetTransparency(ID id) +{ + ML_PRECOND(false); + return ArrMaterials->mtlGetTransparency(id); +} + +SX_LIB_API void SMtrl_MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetTypeReflection(id, type); +} + +SX_LIB_API MTLTYPE_REFLECT SMtrl_MtlGetTypeReflection(ID id) +{ + ML_PRECOND(MTLTYPE_REFLECT_NONE); + return ArrMaterials->mtlGetTypeReflection(id); +} + +//************************************************************************** + +SX_LIB_API void SMtrl_MtlSetMaskTex(ID id, const char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetMaskTex(id, szTexture); +} + +SX_LIB_API void SMtrl_MtlGetMaskTex(ID id, char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlGetMaskTex(id, szTexture); +} + +SX_LIB_API void SMtrl_MtlSetMRTex(ID id, int iChannel, const char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetMRTex(id, iChannel, szTexture); +} + +SX_LIB_API void SMtrl_MtlGetMRTex(ID id, int iChannel, char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlGetMRTex(id, iChannel, szTexture); +} + +SX_LIB_API void SMtrl_MtlSetDTex(ID id, int iChannel, const char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetDTex(id, iChannel, szTexture); +} + +SX_LIB_API void SMtrl_MtlGetDTex(ID id, int iChannel, char *szTexture) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlGetDTex(id, iChannel, szTexture); +} + +SX_LIB_API void SMtrl_MtlSetStdVS(ID id, MTL_SHADERSTD type, bool isSend) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetStdVS(id, type, isSend); +} + +SX_LIB_API bool SMtrl_MtlGetStdVS(ID id, MTL_SHADERSTD type) +{ + ML_PRECOND(false); + return ArrMaterials->mtlGetStdVS(id, type); +} + +SX_LIB_API void SMtrl_MtlSetStdPS(ID id, MTL_SHADERSTD type, bool isSend) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetStdPS(id, type, isSend); +} + +SX_LIB_API bool SMtrl_MtlGetStdPS(ID id, MTL_SHADERSTD type) +{ + ML_PRECOND(false); + return ArrMaterials->mtlGetStdPS(id, type); +} + + +SX_LIB_API void SMtrl_MtlSetUserDataVS(ID id, int iComponent, float fValue) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetUserDataVS(id, iComponent, fValue); +} + +SX_LIB_API float SMtrl_MtlGetUserDataVS(ID id, int iComponent) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetUserDataVS(id, iComponent); +} + +SX_LIB_API void SMtrl_MtlSetUserDataVS_InPS(ID id, bool isSendPS) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetUserDataVS_InPS(id, isSendPS); +} + +SX_LIB_API bool SMtrl_MtlGetUserDataVS_InPS(ID id) +{ + ML_PRECOND(false); + return ArrMaterials->mtlGetUserDataVS_InPS(id); +} + +SX_LIB_API void SMtrl_MtlSetUserDataPS(ID id, int iComponent, float fValue) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetUserDataPS(id, iComponent, fValue); +} + +SX_LIB_API float SMtrl_MtlGetUserDataPS(ID id, int iComponent) +{ + ML_PRECOND(-1); + return ArrMaterials->mtlGetUserDataPS(id, iComponent); +} + +SX_LIB_API void SMtrl_MtlSetUserDataPS_InVS(ID id, bool isSendVS) +{ + ML_PRECOND(_VOID); + ArrMaterials->mtlSetUserDataPS_InPS(id, isSendVS); +} + +SX_LIB_API bool SMtrl_MtlGetUserDataPS_InVS(ID id) +{ + ML_PRECOND(false); + return ArrMaterials->mtlGetUserDataPS_InPS(id); +} diff --git a/source/mtrl/sxmtrl.h b/source/mtrl/sxmtrl.h new file mode 100644 index 0000000000000000000000000000000000000000..153afb63a3ec565f08018a0501edad5e44cd875f --- /dev/null +++ b/source/mtrl/sxmtrl.h @@ -0,0 +1,832 @@ + +/*********************************************************** +Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +/*! +\file +Заголовочный файл sxmtrl - библиотеки материалов +*/ + +/*! \defgroup sxmtrl sxmtrl - библиотека материалов +@{ +*/ + +#ifndef __SXMTRL_H +#define __SXMTRL_H + +#if defined(_DEBUG) +#pragma comment(lib, "sxgcore_d.lib") +#else +#pragma comment(lib, "sxgcore.lib") +#endif + +#undef SX_LIB_API +#define SX_LIB_API extern "C" __declspec (dllimport) +#include + +#ifdef SX_DLL +#undef SX_LIB_API +#define SX_LIB_API extern "C" __declspec (dllexport) +#endif + +#include + +/*! \name Базовые функции библиотеки +@{*/ + +//! версия подсистемы +SX_LIB_API long SMtrl_0GetVersion(); + +//! установить функцию обработки сообщений +SX_LIB_API void SMtrl_Dbg_Set(report_func rf); + +//! инициализция подсистемы +SX_LIB_API void SMtrl_0Create( + const char *szName, //!< присваиваемое имя + bool isUnic = true //!< должна ли подсистема быть уникальной по имени + ); + +//! уничтожить подсистему +SX_LIB_API void SMtrl_AKill(); + +//!@} + +/*! \name Обработка потери/восстановления устройства +@{*/ + +//! вызывать при потрете устройства +SX_LIB_API void SMtrl_OnLostDevice(); + +//! вызывать при восстановлении устройства +SX_LIB_API void SMtrl_OnResetDevice(); + +//!@} + +//! обновление данных всей библиотеки +SX_LIB_API void SMtrl_Update( + DWORD timeDelta //!< время рендера кадра в млсек + ); + +//############################################################################# + +/*! \defgroup sxmtrl_mtl Система материалов + \ingroup sxmtrl +@{*/ + +/*! максимальная длина имени директории материала */ +#define MTL_MAX_SIZE_DIR SXGC_LOADTEX_MAX_SIZE_DIR + +/*! максимальная длина имени материала (без директории) */ +#define MTL_MAX_SIZE_NAME SXGC_LOADTEX_MAX_SIZE_NAME + +/*! максимальное количество обновлений статических отражений, в первый момент рендера */ +#define MTL_REF_UPDATE_MAX_COUNT_FOR_STATIC 3 + +/*! \name Дистанции при которых будут сниженно или повышено количество отрисовок для отражений +меньше #MTL_REF_UPDATE_L0_DIST - обновление будет каждый кадр +больше #MTL_REF_UPDATE_L2_DIST - обновления не будет +@{*/ + +#define MTL_REF_UPDATE_L0_DIST 10 +#define MTL_REF_UPDATE_L1_DIST 30 +#define MTL_REF_UPDATE_L2_DIST 70 + +//!@} + +/*! \name Параметры альфа теста + В данной реалзиации 2 вида альфа теста, принудительный (#SMtrl_MtlSetForceblyAlphaTest) и назначаемый непосредственно материалом + \note функция альфа теста D3DCMP_GREATEREQUAL +@{*/ + +/*! значение свободного альфа теста (назначаемого материалом) */ +#define MTL_ALPHATEST_FREE_VALUE 64 + +/*! значение принудительного альфа теста */ +#define MTL_ALPHATEST_FORCEBLY_VALUE 8 + +//!@} + +/*! \name Значения параметров освещения по умолчанию + Данные значения по умолчанию будут применены к материалами которые не удалось загрузить, либо к стандартным материалам +@{*/ + +//! занчение шероховатости по умолчанию +#define MTL_LIGHTING_DEFAULT_ROUGHNESS 250.f/255.f + +//! значение f0 (отражательной способности поверхности) по умолчанию +#define MTL_LIGHTING_DEFAULT_F0 2.f/255.f + +//! значение thickness (толщина - на сколько будет использована диффузная составляющая, для твердых поверхностей - 1, для листьев деревьев и травы <1) по умолчанию +#define MTL_LIGHTING_DEFAULT_THICKNESS 255.f/255.f + +//!@} + +/*! \name Параметры отражений +@{*/ + +/*! размер текстур с отражениями */ +#define MTL_REF_TEX_SIZE 512 + +/*! ближняя плоскость отсечения */ +#define MTl_REF_PROJ_NEAR 0.25 + +/*! дальняя плоскость отсечения, или дистанция на которую будет рендер всего в текстуру отражений */ +#define MTl_REF_PROJ_FAR 100 + +//!@} + +/*! \name Виртуальные директории + \warning Имя виртуальной директории должно быть единичным символом (сделано для простоты сравнения), +и как следствие нежелательно использоавть реальную директорию с таким именем для текстур либо материалов, +и реальные директории не должны начинаться с данных символов +@{*/ + +//! имя виртуальной директории по умолчанию для "ручных" текстур с параметрами освещения +#define MTL_VIRTUAL_DIR_HAND_MTL '0' + +//! имя виртуальной директории по умолчанию для стандартных (встроенных) материалов +#define MTL_VIRTUAL_DIR_STD_MTL "mtrldef" + +//!@} + +/*! \name Текстурные регистры +Распределение регистров между текстурами которые будут отправляться для формирования данных +@{*/ + +/*!< основная текстура */ +#define MTL_TEX_R_MAIN 0 + +/*!< маска */ +#define MTL_TEX_R_MASK 1 + +/*! стартовый регистр для детальных текстур + \warning 4 следующих (включая указанный) будует заполнены детальными текстурами, поэтому никакие другие текстуры в [MTL_TEX_R_DETAIL, MTL_TEX_R_DETAIL+3] не должны отправляться + \note Текстуры для каждого канала будут отправляться последовательно: r, g, b, a - MTL_TEX_R_DETAIL, MTL_TEX_R_DETAIL + 1, MTL_TEX_R_DETAIL + 2, MTL_TEX_R_DETAIL + 3 +*/ +#define MTL_TEX_R_DETAIL 2 + +/*! стартовый регистр для микрорельефных текстур +\warning 4 следующих (включая указанный) будует заполнены микрорельефными текстурами, поэтому никакие другие текстуры в [MTL_TEX_R_MICRO, MTL_TEX_R_MICRO+3] не должны отправляться +\note Текстуры для каждого канала будут отправляться последовательно: r, g, b, a - MTL_TEX_R_MICRO, MTL_TEX_R_MICRO + 1, MTL_TEX_R_MICRO + 2, MTL_TEX_R_MICRO + 3 +*/ +#define MTL_TEX_R_MICRO 6 + + +/*! текстура с параметрами освещения */ +#define MTL_TEX_R_PARAM_LIGHT 10 + +/*! текстура с отражениями */ +#define MTL_TEX_R_REFLECTION 12 + +/*! текстура с преломлениями */ +#define MTL_TEX_R_REFRACTION 13 + +/*! текстура с текущей глубиной */ +#define MTL_TEX_R_CURR_DEPTH 14 + +//!@} + +//! типы отражений +enum MTLTYPE_REFLECT +{ + //! нет отражения + MTLTYPE_REFLECT_NONE, + + //! плоское + MTLTYPE_REFLECT_PLANE, + + //! объемное динамическое + MTLTYPE_REFLECT_CUBE_DYNAMIC, + + //! объемное статическое, обработка идет первые несколько кадров, затем не обновляется + MTLTYPE_REFLECT_CUBE_STATIC +}; + +//! сорт материала +enum MTLSORT +{ + //! непрозрачный + MTLSORT_OPAQUE = 0x00000001, + + //! прозрачный + MTLTYPE_TRANSPARENCY = 0x00000010, + + //! непрозрачный + MTLSORT_LIGHTED = 0x00000100, + + //! прозрачный + MTLTYPE_ULIT = 0x00001000, + + //! непрозрачный освещаемый + /*MTLSORT_OPAQUE_LIGHTED, + + //! непрозрачный не освещаемый + MTLSORT_OPAQUE_UNLIT,*/ + + + //! полупрозрачный освещаемый + /*MTLTYPE_TRANSPARENCY_LIGHTED, + + //! полупрозрачный не освещаемый + MTLTYPE_TRANSPARENCY_UNLIT,*/ +}; + +/*! \name Возможные слои +@{*/ + +//! непрозрачные неосвещаемые +#define MTLTYPE_LAYER_OPAQUE_UNLIT 0.0f + +//! прозрачные неосвещаемые +#define MTLTYPE_LAYER_TRANSPARENT_UNLIT 0.666667f + +//! непрозрачные освещаемые +#define MTLTYPE_LAYER_OPAQUE_LIGHT 0.333333f + +//! прозрачные освещаемые +#define MTLTYPE_LAYER_TRANSPARENT_LIGHT 1.0f + +//!@} + +//! тип модели материала +enum MTLTYPE_MODEL +{ + //! статическая геометрия + MTLTYPE_MODEL_STATIC = 0, + + //! растительность трава + MTLTYPE_MODEL_GRASS, + + //! растительность дерево + MTLTYPE_MODEL_TREE, + + //! анимационная модель + MTLTYPE_MODEL_SKIN, + + //! значение по умолчанию + MTLTYPE_MODEL_DEFAULT = MTLTYPE_MODEL_STATIC +}; + +//! физический тип материала +enum MTLTYPE_PHYSIC +{ + MTLTYPE_PHYSIC_CONCRETE = 0, //!< бетон + + //! значение по умолчанию + MTLTYPE_PHYSIC_DEFAULT = MTLTYPE_PHYSIC_CONCRETE, + + //! металл + MTLTYPE_PHYSIC_METAL, + + //! стекло + MTLTYPE_PHYSIC_GLASS, + + //! пластик + MTLTYPE_PHYSIC_PLASTIC, + + //! дерево + MTLTYPE_PHYSIC_TREE, + + //! плоть + MTLTYPE_PHYSIC_FLESH, + + //! земля/песок + MTLTYPE_PHYSIC_GROUD_SAND, + + //! вода + MTLTYPE_PHYSIC_WATER, + + //! листва/трава + MTLTYPE_PHYSIC_LEAF_GRASS, + + //! количество типов + MPT_COUNT +}; + +//! данные отправляемые в шейдеры +enum MTL_SHADERSTD +{ + //! мировая матрица (трансформации модели), world + MTL_SHADERSTD_MATRIX_WORLD = 0, + + //! матрица вида, view + MTL_SHADERSTD_MATRIX_VIEW, + + //! матрица проекции, projection + MTL_SHADERSTD_MATRIX_PROJECTION, + + //! world * view + MTL_SHADERSTD_MATRIX_WORLDVIEW, + + //! world * view * projection + MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ, + + //! позиция камеры/наблюдателя + MTL_SHADERSTD_CAMPOS, + + //! данные о времени float2(CountTimeRender,TimeDelta) + MTL_SHADERSTD_TIMEDELTA, + + //! размеры окна рендера + MTL_SHADERSTD_WINSIZE, + + //! пользовательские данные (float4) + MTL_SHADERSTD_USERDATA +}; + +/*! \name Загрузка/сохранение + \note Файл загрузки/сохранения представлен простым конфигурационным файлом (ini) который можно обрабатывать посредством #ISXLConfig + \todo Расписать организацию конфигурационного файла загрузки/сохранения для материала +@{*/ + +/*! загрузка материала, возвращает уникальный идентификатора материала, + \note все материалы оборачиваются в специальную структуру, поэтому дубликатов среди идентификаторов материалов нет + \note любой повторно загружаемый материал не загружается, а лишь дублирует обертку, со ссылкой на внутренности оберкти + */ +SX_LIB_API ID SMtrl_MtlLoad( + const char *szName, //!< имя_материала.расширение + MTLTYPE_MODEL mtl_type = MTLTYPE_MODEL_STATIC //!< тип модели материала на случай если материал не будет загружен/найден + ); + +//! перезагрузка материала +SX_LIB_API void SMtrl_MtlReloadMaterial( + ID id, //!< идентификатор материала + const char *szName = 0 //!< на случай замены существующего материала другим + ); + +/*! сохранить материал по id + \note Сохранение происходит по отноительному пути в директория/директория_имяфайла.mtl +*/ +SX_LIB_API void SMtrl_MtlSave(ID id); + +//!@} + +/*! очитска, удаляет все загруженные материалы (но место в массиве под них остается), все стандартные остаются + \warning Отражения не удаляются а помещаются в очередь удаления, так как могут сожеражть в себе идентификаторы, которые необходимы очистить, +для полной очистки необходимо вызывать функцию #SMtrl_MtlDelRefClear. Однако во избежания утечек памяти необходимо очистить идентификаторы, для их получения вызыва функцию #SMtrl_MtlDelRefGetIDArr +*/ +SX_LIB_API void SMtrl_MtlClear( + bool isClearRefDel //!< очищать ли очередь удаления отражений, на тот случай если идентификаторы в отражениях больше не действительны + ); + +//! возвращает общее количество материалов +SX_LIB_API long SMtrl_MtlGetCount(); + +//! возвращает тип модели материала по id +SX_LIB_API MTLTYPE_MODEL SMtrl_MtlGetTypeModel(ID id); + +//! возвращает сорт материала по id +SX_LIB_API UINT SMtrl_MtlGetSort(ID id); + +/*! установка типа модели материала по id + \warning меняется только внутренний флаг (определение)!!! все остальное для данного типа надо загружать вручную, сделано для больших возможностей построения материалов +*/ +SX_LIB_API void SMtrl_MtlSetTypeModel(ID id, MTLTYPE_MODEL type_model); + +//! установка параметров материала по id, вызывается перед DIP +SX_LIB_API void SMtrl_MtlRender( + ID id, //!< идентификатор материала + const float4x4 *pWorld //!< указатель на мировую матрицу модели, либо 0 - тогда будет принята единичная матрица + ); + +//! стандартная отрисовка материала, используются стандартные шейдеры, нужно для теней, отражений и прочего +SX_LIB_API void SMtrl_MtlRenderStd( + MTLTYPE_MODEL type, //!< тип материала из MtlTypeModel + const float4x4 *pWorld, //!< мировая матрица трансформации, либо 0 и будет применена единичная матрица + ID idSlot, //!< текстурный слот в который установить текстуру + ID idMtl //!< идентификатор материала из которого будет браться текстура + ); + +//! установка параметров материала для рендера источника света +SX_LIB_API void SMtrl_MtlRenderLight( + const float4_t *pColor, //!< rgb - цвет, w зарезервирован + const float4x4 *pWorld //!< аналогично #SMtrl_MtlRender + ); + +//! установить текстуру из материала id в текстурный слот slot +SX_LIB_API void SMtrl_MtlSetMainTexture(ID idSlot, ID id); + + +//! установка физического типа материала +SX_LIB_API void SMtrl_MtlSetPhysicMaterial(ID id, MTLTYPE_PHYSIC type); + +//! возвращает текущий тип физического материала +SX_LIB_API MTLTYPE_PHYSIC SMtrl_MtlGetPhysicMaterial(ID id); + +//! возвращает id стандартного материала для определенной модели материалов указанной в #MtlTypeModel +SX_LIB_API ID SMtrl_MtlGetStdMtl(MTLTYPE_MODEL type_model); + +/*! \name Управление полупрозрачными поверхностями +Каждый выводимый пиксель помечается номером поверхности к которой он относится + - 0 - пусто + - 1 - непрозрачная геометрия + - все что больше 1 значит полупрозрачная геометрия + \note Если инкремент установлен то отрисовка каждого материала будет инкрементировать внутренний счетчик, присваивая каждому пикселю поверхности идентификатор поверхности. + \note На данный момент максимальное значение полупрозрачных поверхностей может быть только 255 (8 бит) +@{*/ + +/*! установка инкремента идентификатора поверхностей + \note К примеру для диференциации (разделения) пикселей при смешивании всех слоев изображения, +без разделения по принадлжености к определнной поверхности будет трудно/невозможно (пока выхода нет) корректно смешать все слои +*/ +SX_LIB_API void SMtrl_MtlSetIsIncrCountSurf(bool bf); + +//! установлен ли инкремент поверхностей +SX_LIB_API bool SMtrl_MtlGetIsIncrCountSurf(); + +//! обнуление идентификатора отрисованных поверхностей (к примеру при новом кадре) +SX_LIB_API void SMtrl_MtlNullingCurrCountSurf(); + +//! текущее количество отрисованных полупрозрачных поверхностей +SX_LIB_API int SMtrl_MtlGetCurrCountSurf(); + +//! установить текущее количество отрисованных полупрозрачных поверхностей +SX_LIB_API void SMtrl_MtlSetCurrCountSurf(int iCount); + +/*! принудительное включение альфа теста (isat - true - включить, false - выключить) при устновке параметров материала, +к примеру для рендера полупрозрачных поверхностей, чтобы отсечь (условно) полностью прозрачные пиксели +*/ +SX_LIB_API void SMtrl_MtlSetForceblyAlphaTest(bool isEnable); + +//! включен ли принудительный альфа тест +SX_LIB_API bool SMtrl_MtlGetForceblyAlphaTest(); + +//!@} + +/*! \defgroup sxmtrl_mtl_reflect Отражения + \ingroup sxmtrl_mtl + \note Поддерживается 2 вида отражений: + - плоские + - объемные/кубические +@{*/ +//{{ + +//! записать в отражения идентификатор (idArr) для определнной стороны куба/сплита (iCube), соотнести его с идентификатором сущности (idOwner) +SX_LIB_API void SMtrl_RefSetIDArr( + ID id, //!< идентификатор материала + ID idOwner, //!< идентификатор сущности для которой записываем (геометрия, растительность и прочее) + int iCube, //!< условно - сторона куба/сплита для которой записываем + ID idArr //!< идентификатор который надо записать + ); + +//! возвращает идентификатор который был записан для сущности (idOwner) для стороны куба/сплита (iCube), если вообще записывался, если не записывался то <0 +SX_LIB_API ID SMtrl_RefGetIDArr( + ID id, //!< идентификатор материала + ID idOwner, //!< идентификатор сущности для которой было записывано (геометрия, растительность и прочее) + int iCube //!< условно - сторона куба/сплита для которой было записывано + ); + +/*! \name Управление удаленными отражениями +@{*/ + +//! возвращает количество удаленных материалов с отражениями +SX_LIB_API int SMtrl_RefDelGetCount(); + +//! возвращает идентификатор который был записан для сущности (inid) для стороны куба/сплита (cube) +SX_LIB_API ID SMtrl_RefDelGetIDArr( + ID idKey, //!< порядковый номер удаленного материала с отражением + ID idOwner, //!< идентификатор сущности для которой было записано (геометрия, растительность и прочее) + int iCube //!< условно - сторона куба/сплита для которой было записывано + ); + +//! очистка массива удаленных материалов с отражениями +SX_LIB_API void SMtrl_RefDelClear(); + +//!@} + +//! обработка статистики рендера для текущего матриала с отражением +SX_LIB_API bool SMtrl_RefUpdateCountUpdate( + ID id, //!< идентификатора материала + const float3_t *pViewPos //!< позиция наблюдателя, viewpos == 0 вернет false + ); + +/*! обнуление статистикки рендера для данного материала с отражением, +полезно в случаях каких-либо изменений, чтобы эти изменения были видны и в отражениях (актуально для статических отражений) +*/ +SX_LIB_API void SMtrl_RefNullingCountUpdate(ID id); + +//! установка экстремумов материала +SX_LIB_API void SMtrl_RefSetMinMax(ID id, const float3_t *pMin, const float3_t *pMax); + +//! возвращает фрустум отражения, cube - сторона куба +SX_LIB_API const IFrustum* SMtrl_RefGetfrustum( + ID id, //!< идентификатора материала + int iCube //!< сторона куба, если отражение плоское то необходимо указать в cube передать 0, иначе вернет NULL + ); + +SX_LIB_API bool SMtrl_RefIsAllowedRender(ID id); //!< разрешен ли рендер отражений для данного материала в текущий момент + +/*! \name Рендер плоского отражения + \note Перед началом рендера плоских отражений необходимо в регистры матриц в #G_RI_MATRIX_VIEW поместить матрицу вида наблюдателя + \note Порядок рендера: + \code + SMtrl_MtlRefPreRenderPlane(id, plane); + //код рендера всего того что необходимо поместить в текстуру отражений + SMtrl_MtlRefPostRenderPlane(id); + \endcode +@{*/ + +//! первоначальные настройки данных для генерации отражения +SX_LIB_API void SMtrl_RefPreRenderPlane( + ID id, //!< идентификатор материала + D3DXPLANE *pPlane //!< плоскость относительно которой будет считаться отражение + ); + +//! завершающие операции +SX_LIB_API void SMtrl_RefPostRenderPlane(ID id); + +//! возвращает текстуру с плоским отражением (если оно есть, иначе 0) +SX_LIB_API IDirect3DTexture9* SMtrl_RefGetTexPlane(ID id); + +//!@} + +/*! \name Рендер объемного (кубического) отражения + \note Порядок рендера: + \code + SMtrl_RefCubeBeginRender(id, center); + SMtrl_RefCubePreRender(id, cube, world); + //код рендера всего того что необходимо поместить в текстуру отражений + SMtrl_RefCubePostRender(id, cube); + SMtrl_RefCubeEndRender(id, viewpos); + \endcode +@{*/ + +//! установка общих настроек +SX_LIB_API void SMtrl_RefCubeBeginRender( + ID id, //!< идентификатор материала + const float3_t *pCenter //!< центр (позиция) подгруппы модели - откуда будет рендер отражений + ); + +//! установка частных настроек для стороны куба (cube) +SX_LIB_API void SMtrl_RefCubePreRender( + ID id, //!< идентификатор материала + int iCube, //!< сторона куба [0,5] + const float4x4 *pWorld //!< мировая матрица модели + ); + +//! завершающие частные моменты для стороны куба +SX_LIB_API void SMtrl_RefCubePostRender(ID id, int iCube); + +/*! завершающие общие моменты + \note если viewpos == 0 обновления статисктики рендера для текущего материала с отражением не произойдет, +и дабы рационально обрабатывать и статические и динамические отражения необходимо до следующего рендера отражений вызвать SMtrl_MtlRefUpdateCountUpdate +*/ +SX_LIB_API void SMtrl_RefCubeEndRender( + ID id, //!< идентификатор материала + const float3_t *pViewPos //!< позиция наблюдателя, необходимо для обработки разрешения на следующий рендер + ); + +//! возвращает cube текстуру отражением (если оно есть, иначе 0) +SX_LIB_API IDirect3DCubeTexture9* SMtrl_RefCubeGetTex(ID id); + +//!@} + +//!@} sxmtrl_mtl_reflect + + +/*! \defgroup sxmtrl_mtl_propslayer Cвойства поверхности + \ingroup sxmtrl_mtl +@{*/ + +//! установка основной текстуры (загрузка текстуры по имени) +SX_LIB_API void SMtrl_MtlSetTexture(ID id, const char *szPathTex); + +//! в name записывает имя текстуры +SX_LIB_API void SMtrl_MtlGetTexture(ID id, char *szName); + +//! возвращает id текстуры материала +SX_LIB_API ID SMtrl_MtlGetTextureID(ID id); + + +/*! \name Шейдеры для рендера материала + \warning В текущей версии все шейдеры загружаются в версии 3.0 и требуют в качестве старта указывать функцию main + \warning Рекомендуется устанавливать и вершинный и пиксельный шейдеры, так как во врем тестов одно из устройств требовало наличия обоих шейдеров либо отсутствия обоих + \note В аргументах path_vs/path_ps указывается только имя шейдера с расширением, есесно возвращается тоже самое +@{*/ + +//! установка вершинного шейдера +SX_LIB_API void SMtrl_MtlSetVS(ID id, const char *szPathVS); + +//! в name записывает имя текущего вершинного шейдера +SX_LIB_API void SMtrl_MtlGetVS(ID id, char *szName); + +//! установка пиксельного шейдера +SX_LIB_API void SMtrl_MtlSetPS(ID id, const char *szPathPS); + +//! в name записывает имя текущего пикельного шейдера +SX_LIB_API void SMtrl_MtlGetPS(ID id, char *szName); + +//!@} + +//! возвращает коэффициент пробиваемости [0, ], чем больше тем сложнее пробить +SX_LIB_API float SMtrl_MtlGetDurability(ID id); + +//! устанавливает коэффициент пробиваемости [0, ], чем больше тем сложнее пробить +SX_LIB_API void SMtrl_MtlSetDurability(ID id, float fDurability); + + +//! возвращает шанс пробиваемости [0 - пуля летит насквозь, 1 - пуля ударяется] +SX_LIB_API float SMtrl_MtlGetHitChance(ID id); + +//! устанавливает шанс пробиваемости [0 - пуля летит насквозь, 1 - пуля ударяется] +SX_LIB_API void SMtrl_MtlSetHitChance(ID id, float fHitChance); + + +//! возвращает плотность материала кг/м3 +SX_LIB_API float SMtrl_MtlGetDensity(ID id); + +//! устанавливает плотность материала кг/м3 +SX_LIB_API void SMtrl_MtlSetDensity(ID id, float fDensity); + + +//! используется ли альфа тест для материала +SX_LIB_API bool SMtrl_MtlGetUsingAlphaTest(ID id); + +//! установка использования альфа теста +SX_LIB_API void SMtrl_MtlSetUsingAlphaTest(ID id, bool isUsing); + +/*! освещение материала id + \note если материал не освещается то будет выведен в цвете накладываемым материалом +*/ +SX_LIB_API void SMtrl_MtlSetLighting(ID id, bool isLighting); + +//! освещается ли материал +SX_LIB_API bool SMtrl_MtlGetLighting(ID id); + +/*! \name Параметры освещения. + \note Для более точной/тонкой настройки освещения материала рекомендуется использовать текстуру с параметрами освещения +(к прмиеру когда в одной поверхности разные материалы, к примеру дерево, метал и камень, то в текстуре можно указать параметры освещения для каждого пикселя), +однако если текстуры нет то будут использованы установленные парметры освещения для всей поверхности +@{*/ + +//! установка использования текстуры с параметрами освещения +SX_LIB_API void SMtrl_MtlSetIsTextureLighting(ID id, bool isTexLighting); + +//! используется ли текстура с параметрами для освещения +SX_LIB_API bool SMtrl_MtlGetIsTextureLighting(ID id); + + +//! загрузка текстуры с парамтерами освещения +SX_LIB_API void SMtrl_MtlSetTextureLighting(ID id, const char *szPathTex); + +//! в path_tex записывает имя текстуры с параметрами освещения +SX_LIB_API void SMtrl_MtlGetTextureLighting(ID id, char *szPathTex); + + +//! установка шероховатости (0-1) +SX_LIB_API void SMtrl_MtlSetRoughness(ID id, float fRoughness); + +//! возвращает текущее значение шероховатости поверхности +SX_LIB_API float SMtrl_MtlGetRoughness(ID id); + + +//! установка просвечиваемости (толщины для графики (0, 1)), 0 - не принимает затенение, 1 - полностью принимает затенение +SX_LIB_API void SMtrl_MtlSetThickness(ID id, float fThickness); + +//! возвращает просвечиваемости (толщины для графики (0, 1)), 0 - не принимает затенение, 1 - полностью принимает затенение +SX_LIB_API float SMtrl_MtlGetThickness(ID id); + +//! установка отражательной способности поверхности (0-1) +SX_LIB_API void SMtrl_MtlSetF0(ID id, float fF0); + +//! возвращает текущее значение отражательной способности поверхности +SX_LIB_API float SMtrl_MtlGetF0(ID id); + +//!@} + +/*! \name Полупрозрачность +Под полупрозрачными материалами следует понимать такие материалы, прозрачность которых в среднем находится в пределах [0.5, 1) и минимальный процент полупрозрачного периметра 50% +@{*/ + +//! установка свойства полупрозрачности +SX_LIB_API void SMtrl_MtlSetTransparency(ID id, bool isTransparent); + +//! возвращает текущее значение свойства полупрозрачности для материала +SX_LIB_API bool SMtrl_MtlGetTransparency(ID id); + +//!@} + +/*! \name Отражения окружения, типы из #MtlTypeReflect +@{*/ + +//! установка типа отражений +SX_LIB_API void SMtrl_MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type); + +//! возвращает текущий тип отражений для материала +SX_LIB_API MTLTYPE_REFLECT SMtrl_MtlGetTypeReflection(ID id); + +//!@} + +/*! \name Детальность и микрорельеф +Поверхность может содержать до 4 детальных текстур и до 4 текстур с микрорельефом. +Данные для определения наложения текстур (детальных и микрорельефных) указываются в маске - +на каждый канал текстуры маски по одной детальной и микрорельефной текстуре, +то есть канал маски определет связанные между собой и детальную и микрорельефную текстуры + \note В аргументах channel - RGBA - 0,1,2,3 +@{*/ + +//! загрузка маски наложения +SX_LIB_API void SMtrl_MtlSetMaskTex(ID id, const char *szPathTex); + +//! в path_tex записывает текущее имя маски наложения +SX_LIB_API void SMtrl_MtlGetMaskTex(ID id, char *szPathTex); + +//! загрузка текстуры микрорельефа, на каждый канал +SX_LIB_API void SMtrl_MtlSetMRTex( + ID id, //!< идентификатор материала + int iChannel, //!< номер канала RGBA - 0,1,2,3 + const char *szPathTex //!< имя текстуры с расширением + ); + +//! в path_tex запишет текущее имя текстуры микрорельефа для канала channel +SX_LIB_API void SMtrl_MtlGetMRTex(ID id, int iChannel, char *szPathTex); + +//! загрузка детальной текстуры, на каждый канал +SX_LIB_API void SMtrl_MtlSetDTex( + ID id, //!< идентификатор материала + int iChannel, //!< номер канала RGBA - 0,1,2,3 + const char *szPathTex //!< имя текстуры с расширением + ); + +//! в path_tex запишет текущее имя детальной текстуры для канала channel +SX_LIB_API void SMtrl_MtlGetDTex(ID id, int iChannel, char *szPathTex); + +//!@} + +/*! \name Стандартные параметры для отправки в шейдер (в вершинный и пиксельный раздельно), данные из #MtlTransShaderStd +@{*/ + +//! отправка стадартных данных в вершинный шейдер +SX_LIB_API void SMtrl_MtlSetStdVS( + ID id, //!< идентификатор материала + MTL_SHADERSTD type, //!< тип значения которое нужно отправить, одно из значений #MtlTransShaderStd + bool isSend //!< true - отправлять, false - не отправлять + ); + +//! установлена ли отпрвка значения type в вершинный шейдер +SX_LIB_API bool SMtrl_MtlGetStdVS(ID id, MTL_SHADERSTD type); + +//! отправка стадартных данных в пиксельный шейдер +SX_LIB_API void SMtrl_MtlSetStdPS( + ID id, //!< идентификатор материала + MTL_SHADERSTD type, //!< тип значения которое нужно отправить, одно из значений #MtlTransShaderStd + bool isSend //!< true - отправлять, false - не отправлять + ); + +//! установлена ли отпрвка значения type в пиксельный шейдер +SX_LIB_API bool SMtrl_MtlGetStdPS(ID id, MTL_SHADERSTD type); + +//!@} + +/*! \name Дополнительные пользовательские данные в виде float4 (предел [0-1] для стандарта, иное вне стандарта, но допустимо) + \note Данные для вершинного и пиксельного шейдера раздельны. Отправляется float4. +Однако данные и из пиксельного могут быть отправленны в вершинный и наоборот. +В итоге в шейдере может быть 2 float4 пользовательских вектора с данными. +Но если вектор определен для пиксельного то он все-равно будет отправлен в пиксельный шейдер, даже если и придназначалася для вершинного. + \note В аргументах component - xyzw - 0,1,2,3 +@{*/ + +//! установка значения компоненты вектора для вершинного шейдера +SX_LIB_API void SMtrl_MtlSetUserDataVS( + ID id, //!< идентификатор материала + int iComponent, //!< компонента вектора xyzw - 0,1,2,3 + float fValue //!< значение компоненты + ); + +//! возвращает значение компоненты вектора, который отправляется в вершинный шейдер +SX_LIB_API float SMtrl_MtlGetUserDataVS(ID id, int iComponent); + +//! установка отправки float4 вектора, предназначенного для вершинного шейдера, в пиксельный шейдер +SX_LIB_API void SMtrl_MtlSetUserDataVS_InPS(ID id, bool isSendPs); + +//! отправляется ли float4 вектор, предназначенный для вершинного шейдера, в пиксельный шейдер +SX_LIB_API bool SMtrl_MtlGetUserDataVS_InPS(ID id); + + +//! установка значения компоненты вектора для пиксельного шейдера +SX_LIB_API void SMtrl_MtlSetUserDataPS( + ID id, //!< идентификатор материала + int iComponent, //!< компонента вектора xyzw - 0,1,2,3 + float fValue //!< значение компоненты + ); + +//! возвращает значение компоненты вектора, который отправляется в пиксельный шейдер +SX_LIB_API float SMtrl_MtlGetUserDataPS(ID id, int iComponent); + +//! установка отправки float4 вектора, предназначенного для пиксельного шейдера, в вершинный шейдер +SX_LIB_API void SMtrl_MtlSetUserDataPS_InVS(ID id, bool isSendVs); + +//! отправляется ли float4 вектор, предназначенный для пиксельного шейдера, в вершинный шейдер +SX_LIB_API bool SMtrl_MtlGetUserDataPS_InVS(ID id); + +//!@} + +//!@} sxmtrl_mtl_propslayer + +//!@} sxmtrl_mtl + +#endif + +//!@} sxmtrl diff --git a/source/mtrl/sxmtrl_dll.cpp b/source/mtrl/sxmtrl_dll.cpp new file mode 100644 index 0000000000000000000000000000000000000000..88b1ec58eac1f5e48ba53b6f764552b3f797850d --- /dev/null +++ b/source/mtrl/sxmtrl_dll.cpp @@ -0,0 +1,24 @@ + +/*********************************************************** +Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018 +See the license in LICENSE +***********************************************************/ + +#include + +BOOL APIENTRY DllMain(HMODULE hModule, + DWORD ul_reason_for_call, + LPVOID lpReserved + ) +{ + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: + case DLL_THREAD_ATTACH: + case DLL_THREAD_DETACH: + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} + diff --git a/source/particles/emitter.cpp b/source/particles/emitter.cpp index 5f511defca65042420362cbd0d38819c7a5f936d..f890270b5b2513f25e91f7933fa9ec42f0d7583a 100644 --- a/source/particles/emitter.cpp +++ b/source/particles/emitter.cpp @@ -219,21 +219,21 @@ void Emitter::computeLighting() { Arr[i].Ambient.x = Arr[i].Ambient.y = Arr[i].Ambient.z = Arr[i].Ambient.w = 0; - for (int k = 0; k 1.f) invdist = 1.f; else if (invdist < 0.f) diff --git a/source/particles/sxparticles.h b/source/particles/sxparticles.h index c931ca4be67139916e27b4d447217207dbab29cd..79cee824269aa1b1608b856c9516d59c09cfd3a1 100644 --- a/source/particles/sxparticles.h +++ b/source/particles/sxparticles.h @@ -35,12 +35,12 @@ See the license in LICENSE #include #if defined(_DEBUG) -#pragma comment(lib, "sxmtllight_d.lib") +#pragma comment(lib, "sxlight_d.lib") #else -#pragma comment(lib, "sxmtllight.lib") +#pragma comment(lib, "sxlight.lib") #endif -#include +#include #ifdef SX_DLL #undef SX_LIB_API diff --git a/source/physics/PhyWorld.cpp b/source/physics/PhyWorld.cpp index bfad99dbdb3a73f680618568141c4d7e17fcb689..131da221d402550269707f53c2368f54a337b2f9 100644 --- a/source/physics/PhyWorld.cpp +++ b/source/physics/PhyWorld.cpp @@ -8,7 +8,7 @@ See the license in LICENSE #include #include #include -#include +#include #include <../Extras/Serialize/BulletWorldImporter/btBulletWorldImporter.h> @@ -118,6 +118,9 @@ void CPhyWorld::loadGeom(const char * file) { return; } + + unloadGeom(); + float3_t ** ppVertices; int32_t * pVertexCount; uint32_t ** ppIndices; @@ -162,7 +165,7 @@ void CPhyWorld::loadGeom(const char * file) } for(int i = 0; i < pIndexCount[tc]; i += 3) { - //m_pGeomMtlTypes[iFace++] = SML_MtlGetPhysicMaterial(ppMtls[tc][i]); + //m_pGeomMtlTypes[iFace++] = SMtrl_MtlGetPhysicMaterial(ppMtls[tc][i]); m_pGeomMtlIDs[iFace++] = ppMtls[tc][i]; m_pGeomStaticCollideMesh->addTriangleIndices(ppIndices[tc][i] + VC, ppIndices[tc][i + 1] + VC, ppIndices[tc][i + 2] + VC); } @@ -218,7 +221,7 @@ void CPhyWorld::loadGeom(const char * file) int iIC = 0; for(int i = 0; i < green_arr_count_index[num_green]; i += 3) { - MTLTYPE_PHYSIC type = SML_MtlGetPhysicMaterial(green_arr_mtl[num_green][i]); + MTLTYPE_PHYSIC type = SMtrl_MtlGetPhysicMaterial(green_arr_mtl[num_green][i]); if (type != MTLTYPE_PHYSIC_LEAF_GRASS) { iIC += 3; @@ -235,7 +238,7 @@ void CPhyWorld::loadGeom(const char * file) for(int i = 0; i < green_arr_count_index[num_green]; ++i) { idx = green_arr_index[num_green][i]; - type = SML_MtlGetPhysicMaterial(green_arr_mtl[num_green][idx]); + type = SMtrl_MtlGetPhysicMaterial(green_arr_mtl[num_green][idx]); if (type != MTLTYPE_PHYSIC_LEAF_GRASS) { found = false; @@ -259,7 +262,7 @@ void CPhyWorld::loadGeom(const char * file) float3 a, b, c, x, y, z; for(int i = 0; i < green_arr_count_index[num_green]; i += 3) { - type = SML_MtlGetPhysicMaterial(green_arr_mtl[num_green][i]); + type = SMtrl_MtlGetPhysicMaterial(green_arr_mtl[num_green][i]); if (type == MTLTYPE_PHYSIC_LEAF_GRASS) { continue; @@ -503,11 +506,11 @@ bool CPhyWorld::importGeom(const char * file) AssotiativeArray mMatMap; const AssotiativeArray::Node *pMatMapNode; - int iMatCount = SML_MtlGetCount(); + int iMatCount = SMtrl_MtlGetCount(); for(int i = 0; i < iMatCount; ++i) { szTmp[0] = 0; - SML_MtlGetTexture(i, szTmp); + SMtrl_MtlGetTexture(i, szTmp); mMatMap[szTmp] = i; } @@ -639,7 +642,7 @@ bool CPhyWorld::exportGeom(const char * _file) if(!aszMatNames[m_pGeomMtlIDs[i]]) { szTmp[0] = 0; - SML_MtlGetTexture(m_pGeomMtlIDs[i], szTmp); + SMtrl_MtlGetTexture(m_pGeomMtlIDs[i], szTmp); aszMatNames[m_pGeomMtlIDs[i]] = _allocStr(szTmp); } } @@ -681,7 +684,7 @@ MTLTYPE_PHYSIC CPhyWorld::getMtlType(const btCollisionObject *pBody, const btCol ID idMtl = getMtlID(pBody, pShapeInfo); if(ID_VALID(idMtl)) { - return(SML_MtlGetPhysicMaterial(idMtl)); + return(SMtrl_MtlGetPhysicMaterial(idMtl)); } return(MTLTYPE_PHYSIC_DEFAULT); } diff --git a/source/physics/PhyWorld.h b/source/physics/PhyWorld.h index 5d4c64d116ea9e4498521911726d0e4b050ad512..1cb6ee3bd7e695f60396c8710bf7810a0390ba90 100644 --- a/source/physics/PhyWorld.h +++ b/source/physics/PhyWorld.h @@ -19,7 +19,7 @@ See the license in LICENSE #include #include -#include +#include #define PHY_MAT_FILE_MAGICK 3630267958475905107 diff --git a/source/physics/sxphysics.h b/source/physics/sxphysics.h index 0b5994b9839b0fbecefb3971cc7a1d7c7666436c..0529ed069964046d849eb35331e089797d709dd8 100644 --- a/source/physics/sxphysics.h +++ b/source/physics/sxphysics.h @@ -21,7 +21,6 @@ See the license in LICENSE #undef SX_LIB_API #define SX_LIB_API extern "C" __declspec (dllimport) -//#include #ifdef SX_DLL #undef SX_LIB_API diff --git a/source/physics/sxphysics_dll.cpp b/source/physics/sxphysics_dll.cpp index 7edc184f79fa48066256ddedde5bef68d9662c52..48322e35911d9321578843c19ea0337861d1daea 100644 --- a/source/physics/sxphysics_dll.cpp +++ b/source/physics/sxphysics_dll.cpp @@ -15,7 +15,8 @@ See the license in LICENSE #if defined(_DEBUG) # pragma comment(lib, "sxcore_d.lib") # pragma comment(lib, "sxgeom_d.lib") -# pragma comment(lib, "sxmtllight_d.lib") +# pragma comment(lib, "sxlight_d.lib") +# pragma comment(lib, "sxmtrl_d.lib") # pragma comment(lib, "BulletDynamics_vs2010_debug.lib") # pragma comment(lib, "BulletCollision_vs2010_debug.lib") # pragma comment(lib, "LinearMath_vs2010_debug.lib") @@ -23,7 +24,8 @@ See the license in LICENSE #else # pragma comment(lib, "sxcore.lib") # pragma comment(lib, "sxgeom.lib") -# pragma comment(lib, "sxmtllight.lib") +# pragma comment(lib, "sxlight.lib") +# pragma comment(lib, "sxmtrl.lib") # pragma comment(lib, "BulletDynamics_vs2010.lib") # pragma comment(lib, "BulletCollision_vs2010.lib") # pragma comment(lib, "LinearMath_vs2010.lib") diff --git a/source/render/camera_update.cpp b/source/render/camera_update.cpp index 13465dd5bf62be07fc5b066346b4780b92c0d069..838864d10e33ec3a418cf748388dd5be39be8948 100644 --- a/source/render/camera_update.cpp +++ b/source/render/camera_update.cpp @@ -11,30 +11,30 @@ void CameraUpdate::UpdateInputKeyBoard(DWORD timeDelta) { //обработка ходьбы if(SSInput_GetKeyState(SIK_W)) - GData::ObjCamera->posFrontBack( - GData::CamWalkParamEditor.x * - (SSInput_GetKeyState(SIK_LSHIFT) ? GData::CamWalkParamEditor.y : 1) * + gdata::pCamera->posFrontBack( + gdata::vCamWalkParamEditor.x * + (SSInput_GetKeyState(SIK_LSHIFT) ? gdata::vCamWalkParamEditor.y : 1) * float(timeDelta) * 0.001f ); if(SSInput_GetKeyState(SIK_S)) - GData::ObjCamera->posFrontBack( - -GData::CamWalkParamEditor.x * - (SSInput_GetKeyState(SIK_LSHIFT) ? GData::CamWalkParamEditor.y : 1) * GData::CamWalkParamEditor.w * + gdata::pCamera->posFrontBack( + -gdata::vCamWalkParamEditor.x * + (SSInput_GetKeyState(SIK_LSHIFT) ? gdata::vCamWalkParamEditor.y : 1) * gdata::vCamWalkParamEditor.w * float(timeDelta) * 0.001f ); if(SSInput_GetKeyState(SIK_A)) - GData::ObjCamera->posLeftRight( - -GData::CamWalkParamEditor.x * - (SSInput_GetKeyState(SIK_LSHIFT) ? GData::CamWalkParamEditor.y : 1) * GData::CamWalkParamEditor.z * + gdata::pCamera->posLeftRight( + -gdata::vCamWalkParamEditor.x * + (SSInput_GetKeyState(SIK_LSHIFT) ? gdata::vCamWalkParamEditor.y : 1) * gdata::vCamWalkParamEditor.z * float(timeDelta) * 0.001f ); if(SSInput_GetKeyState(SIK_D)) - GData::ObjCamera->posLeftRight( - GData::CamWalkParamEditor.x * - (SSInput_GetKeyState(SIK_LSHIFT) ? GData::CamWalkParamEditor.y : 1) * GData::CamWalkParamEditor.z * + gdata::pCamera->posLeftRight( + gdata::vCamWalkParamEditor.x * + (SSInput_GetKeyState(SIK_LSHIFT) ? gdata::vCamWalkParamEditor.y : 1) * gdata::vCamWalkParamEditor.z * float(timeDelta) * 0.001f ); } @@ -50,13 +50,13 @@ void CameraUpdate::UpdateInputMouseRotate(DWORD timeDelta) if(dx) { - GData::ObjCamera->rotRightLeft(float(timeDelta) * *sense * float(dx)); + gdata::pCamera->rotRightLeft(float(timeDelta) * (*sense) * float(dx)); //SetCursorPos(centr.x,cy); } if(dy) { - GData::ObjCamera->rotUpDown(float(timeDelta) * *sense * float(dy)); + gdata::pCamera->rotUpDown(float(timeDelta) * *sense * float(dy)); //SetCursorPos(cx,centr.y); } } @@ -72,7 +72,7 @@ void CameraUpdate::UpdateInputMouseUpDown(DWORD timeDelta) if(dy) { - GData::ObjCamera->posUpDown(5 * float(timeDelta) * *sense * float(-dy)); + gdata::pCamera->posUpDown(5 * float(timeDelta) * *sense * float(-dy)); } } diff --git a/source/render/editor/axes_static.cpp b/source/render/editor/axes_static.cpp index 1a84aedca9743b01295710a17dd1fe66e15a1cb1..33aa3b1b77f5ae3e6019ab556f8f170b25d891be 100644 --- a/source/render/editor/axes_static.cpp +++ b/source/render/editor/axes_static.cpp @@ -19,7 +19,7 @@ CAxesStatic::CAxesStatic() D3DDECL_END() }; - GData::DXDevice->CreateVertexDeclaration(DeclGrid, &m_pVertexDeclaration); + gdata::pDXDevice->CreateVertexDeclaration(DeclGrid, &m_pVertexDeclaration); } CAxesStatic::~CAxesStatic() @@ -30,7 +30,7 @@ CAxesStatic::~CAxesStatic() void CAxesStatic::create(float len) { - GData::DXDevice->CreateVertexBuffer( + gdata::pDXDevice->CreateVertexBuffer( 3 * 2 * sizeof(CVertex), D3DUSAGE_WRITEONLY, 0, @@ -64,11 +64,11 @@ void CAxesStatic::create(float len) void CAxesStatic::render() { - GData::DXDevice->SetTexture(0, 0); - //GData::DXDevice->SetRenderState(D3DRS_LIGHTING, FALSE); + gdata::pDXDevice->SetTexture(0, 0); + //gdata::pDXDevice->SetRenderState(D3DRS_LIGHTING, FALSE); SGCore_ShaderUnBind(); - GData::DXDevice->SetVertexDeclaration(m_pVertexDeclaration); - //GData::DXDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE); - GData::DXDevice->SetStreamSource(0, m_pVertexBuffer, 0, sizeof(CVertex)); - GData::DXDevice->DrawPrimitive(D3DPT_LINELIST, 0, 3); + gdata::pDXDevice->SetVertexDeclaration(m_pVertexDeclaration); + //gdata::pDXDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE); + gdata::pDXDevice->SetStreamSource(0, m_pVertexBuffer, 0, sizeof(CVertex)); + gdata::pDXDevice->DrawPrimitive(D3DPT_LINELIST, 0, 3); } \ No newline at end of file diff --git a/source/render/editor/grid.cpp b/source/render/editor/grid.cpp index 34c438a8871491a6bca5efbf79befc4545400a12..8838b68d261033db77aaf80bbabc75333f362171 100644 --- a/source/render/editor/grid.cpp +++ b/source/render/editor/grid.cpp @@ -19,7 +19,7 @@ CGrid::CGrid() D3DDECL_END() }; - GData::DXDevice->CreateVertexDeclaration(DeclGrid, &m_pVertexDeclaration); + gdata::pDXDevice->CreateVertexDeclaration(DeclGrid, &m_pVertexDeclaration); } CGrid::~CGrid() @@ -30,7 +30,7 @@ CGrid::~CGrid() void CGrid::create(int width, int depth, DWORD color) { - GData::DXDevice->CreateVertexBuffer( + gdata::pDXDevice->CreateVertexBuffer( width * depth * 2 * sizeof(CVertex), D3DUSAGE_WRITEONLY, 0, @@ -70,11 +70,11 @@ void CGrid::create(int width, int depth, DWORD color) void CGrid::render() { - GData::DXDevice->SetTexture(0, 0); - //GData::DXDevice->SetRenderState(D3DRS_LIGHTING, FALSE); + gdata::pDXDevice->SetTexture(0, 0); + SGCore_ShaderUnBind(); - GData::DXDevice->SetVertexDeclaration(m_pVertexDeclaration); - //GData::DXDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE); - GData::DXDevice->SetStreamSource(0, m_pVertexBuffer, 0, sizeof(CVertex)); - GData::DXDevice->DrawPrimitive(D3DPT_LINELIST, 0, m_iCountPoly); + gdata::pDXDevice->SetVertexDeclaration(m_pVertexDeclaration); + + gdata::pDXDevice->SetStreamSource(0, m_pVertexBuffer, 0, sizeof(CVertex)); + gdata::pDXDevice->DrawPrimitive(D3DPT_LINELIST, 0, m_iCountPoly); } \ No newline at end of file diff --git a/source/render/gdata.cpp b/source/render/gdata.cpp index 8b20bccc5cf9753a51640f1732f817773533e9b1..00430164dd35f36d2b041b8cad1a5c4f95efad40 100644 --- a/source/render/gdata.cpp +++ b/source/render/gdata.cpp @@ -6,31 +6,28 @@ See the license in LICENSE #include "gdata.h" -namespace GData +namespace gdata { - IDirect3DDevice9* DXDevice = 0; - - HWND HandleParent3D = 0; - HWND Handle3D = 0; - - //bool IsWindowed = true; + IDirect3DDevice9 *pDXDevice = 0; + HWND hHandleParent3D = 0; + HWND hHandle3D = 0; DS_RT FinalImage = DS_RT_SCENELIGHT; - ICamera* ObjCamera = 0; - ID IDSelectTex = -1; + ICamera *pCamera = 0; + ID idSelectTex = -1; - float2_t NearFar = float2_t(0.025, 400); - float ProjFov = SM_PIDIV4; + float2_t vNearFar = float2_t(0.025, 400); + float fProjFov = SM_PIDIV4; - ID DefaultGeomIDArr = -1; - ID DefaultGreenIDArr = -1; - ID DefaultAnimIDArr = -1; + ID idDefaultGeomArr = -1; + ID idDefaultGreenArr = -1; + ID idDefaultAnimArr = -1; - float3 ConstCurrCamPos; - float3 ConstCurrCamDir; + float3 vConstCurrCamPos; + float3 vConstCurrCamDir; - float4_t CamWalkParamEditor = float4_t( + float4_t vCamWalkParamEditor = float4_t( 10.f, //!< простое движенеи вперед 5.f, //!< коэфициент ускорения 0.7f, //!< коэфициент от основного движения в стороны @@ -39,60 +36,58 @@ namespace GData //матрицы void InitAllMatrix(); - float4x4 MCamView; - float4x4 MCamProj; - float4x4 MLightProj; - float4x4 MRefPlaneSkyProj; - float4x4 MRefCubeSkyProj; + float4x4 mCamView; + float4x4 mCamProj; + float4x4 mLightProj; + float4x4 mRefPlaneSkyProj; + float4x4 mRefCubeSkyProj; //********************************************************************** //! пространство имен с идентификаторами шейдеров - namespace IDsShaders + namespace shaders_id { //! загрузка всех необходимых шейдеров void InitAllShaders(); //! вершинные шейдеры - namespace VS + namespace vs { - ID ScreenOut; - ID ResPos; + ID idScreenOut; + ID idResPos; }; //! пиксельные шейдеры - namespace PS + namespace ps { - ID ScreenOut; - ID ComLightingNonShadow; - ID ComLightingShadow; - - ID BlendAmbientSpecDiffColor; + ID idScreenOut; + ID idComLightingNonShadow; + ID idComLightingShadow; - //ID ToneMapping; + ID idBlendAmbientSpecDiffColor; - ID StencilStr; - ID StencilColumn; - ID StencilStrColumn; - ID UnionAlpha; + ID idStencilStr; + ID idStencilColumn; + ID idStencilStrColumn; + ID idUnionAlpha; }; }; namespace Editors { - bool MoveCamera = true; - CSimulationModel* SimModel = 0; - CGrid* ObjGrid = 0; - CAxesStatic* ObjAxesStatic = 0; + bool canMoveCamera = true; + CSimulationModel *pSimModel = 0; + CGrid *pGrid = 0; + CAxesStatic *pAxesStatic = 0; - bool RenderGrid = false; - bool RenderAxesStatic = false; + bool canRenderGrid = false; + bool canRenderAxesStatic = false; } }; //########################################################################## -void GData::InitAllMatrix() +void gdata::InitAllMatrix() { static const int *r_win_width = GET_PCVAR_INT("r_win_width"); static const int *r_win_height = GET_PCVAR_INT("r_win_height"); @@ -103,47 +98,44 @@ void GData::InitAllMatrix() static const float *r_far = GET_PCVAR_FLOAT("r_far"); static const float *r_default_fov = GET_PCVAR_FLOAT("r_default_fov"); - GData::NearFar.x = *r_near; - GData::NearFar.y = *r_far; - GData::ProjFov = *r_default_fov; + gdata::vNearFar.x = *r_near; + gdata::vNearFar.y = *r_far; + gdata::fProjFov = *r_default_fov; - GData::MCamProj = SMMatrixPerspectiveFovLH(GData::ProjFov, vWinSize.x / vWinSize.y, GData::NearFar.x, GData::NearFar.y); - //GData::MCamProj = SMMatrixOrthographicLH(vWinSize.x / 4, vWinSize.y / 4, GData::NearFar.x, GData::NearFar.y); - GData::MLightProj = SMMatrixPerspectiveFovLH(GData::ProjFov, vWinSize.x / vWinSize.y, GData::NearFar.x, G_DATA_LIGHT_FAR); - //GData::MLightProj = SMMatrixOrthographicLH(vWinSize.x / 4, vWinSize.y / 4, GData::NearFar.x, G_DATA_LIGHT_FAR); + gdata::mCamProj = SMMatrixPerspectiveFovLH(gdata::fProjFov, vWinSize.x / vWinSize.y, gdata::vNearFar.x, gdata::vNearFar.y); + //gdata::MCamProj = SMMatrixOrthographicLH(vWinSize.x / 4, vWinSize.y / 4, gdata::NearFar.x, gdata::NearFar.y); + gdata::mLightProj = SMMatrixPerspectiveFovLH(gdata::fProjFov, vWinSize.x / vWinSize.y, gdata::vNearFar.x, G_DATA_LIGHT_FAR); + //gdata::MLightProj = SMMatrixOrthographicLH(vWinSize.x / 4, vWinSize.y / 4, gdata::NearFar.x, G_DATA_LIGHT_FAR); - GData::MRefPlaneSkyProj = SMMatrixPerspectiveFovLH(GData::ProjFov, vWinSize.x / vWinSize.y, GData::NearFar.x, G_DATA_LIGHT_FAR); - GData::MRefCubeSkyProj = SMMatrixPerspectiveFovLH(SM_PI * 0.5f, 1, GData::NearFar.x, G_DATA_LIGHT_FAR); + gdata::mRefPlaneSkyProj = SMMatrixPerspectiveFovLH(gdata::fProjFov, vWinSize.x / vWinSize.y, gdata::vNearFar.x, G_DATA_LIGHT_FAR); + gdata::mRefCubeSkyProj = SMMatrixPerspectiveFovLH(SM_PI * 0.5f, 1, gdata::vNearFar.x, G_DATA_LIGHT_FAR); - Core_RMatrixSet(G_RI_MATRIX_OBSERVER_PROJ, &GData::MCamProj); - Core_RMatrixSet(G_RI_MATRIX_LIGHT_PROJ, &GData::MLightProj); + Core_RMatrixSet(G_RI_MATRIX_OBSERVER_PROJ, &gdata::mCamProj); + Core_RMatrixSet(G_RI_MATRIX_LIGHT_PROJ, &gdata::mLightProj); - /*Core_RFloatSet(G_RI_FLOAT_OBSERVER_NEAR, GData::NearFar.x); - Core_RFloatSet(G_RI_FLOAT_OBSERVER_FAR, GData::NearFar.y); - Core_RFloatSet(G_RI_FLOAT_OBSERVER_FOV, GData::ProjFov);*/ + /*Core_RFloatSet(G_RI_FLOAT_OBSERVER_NEAR, gdata::NearFar.x); + Core_RFloatSet(G_RI_FLOAT_OBSERVER_FAR, gdata::NearFar.y); + Core_RFloatSet(G_RI_FLOAT_OBSERVER_FOV, gdata::ProjFov);*/ } -void GData::IDsShaders::InitAllShaders() +void gdata::shaders_id::InitAllShaders() { - GData::IDsShaders::VS::ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_quad_render.vs", "pp_quad_render.vs",SHADER_CHECKDOUBLE_PATH); - GData::IDsShaders::PS::ScreenOut = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_quad_render.ps", "pp_quad_render.ps",SHADER_CHECKDOUBLE_PATH); - - //GData::IDsShaders::PS::ToneMapping = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "lighting_tone_mapping.ps", "lighting_tone_mapping.ps",SHADER_CHECKDOUBLE_PATH); - - GData::IDsShaders::VS::ResPos = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_res_pos.vs", "pp_quad_render_res_pos.vs",SHADER_CHECKDOUBLE_PATH); + gdata::shaders_id::vs::idScreenOut = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_quad_render.vs", "pp_quad_render.vs", SHADER_CHECKDOUBLE_PATH); + gdata::shaders_id::ps::idScreenOut = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_quad_render.ps", "pp_quad_render.ps", SHADER_CHECKDOUBLE_PATH); + gdata::shaders_id::vs::idResPos = SGCore_ShaderLoad(SHADER_TYPE_VERTEX, "pp_res_pos.vs", "pp_quad_render_res_pos.vs", SHADER_CHECKDOUBLE_PATH); - GData::IDsShaders::PS::ComLightingNonShadow = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "lighting_com.ps", "lighting_com_nonshadow.ps", SHADER_CHECKDOUBLE_NAME); + gdata::shaders_id::ps::idComLightingNonShadow = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "lighting_com.ps", "lighting_com_nonshadow.ps", SHADER_CHECKDOUBLE_NAME); D3DXMACRO Defines_IS_SHADOWED[] = { { "IS_SHADOWED", "" }, { 0, 0 } }; - GData::IDsShaders::PS::ComLightingShadow = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "lighting_com.ps", "lighting_com_shadow.ps", SHADER_CHECKDOUBLE_NAME, Defines_IS_SHADOWED); - GData::IDsShaders::PS::BlendAmbientSpecDiffColor = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "lighting_blend.ps", "lighting_blend.ps",SHADER_CHECKDOUBLE_PATH); + gdata::shaders_id::ps::idComLightingShadow = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "lighting_com.ps", "lighting_com_shadow.ps", SHADER_CHECKDOUBLE_NAME, Defines_IS_SHADOWED); + gdata::shaders_id::ps::idBlendAmbientSpecDiffColor = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "lighting_blend.ps", "lighting_blend.ps", SHADER_CHECKDOUBLE_PATH); - GData::IDsShaders::PS::UnionAlpha = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_union_alpha.ps", "pp_union_alpha.ps",SHADER_CHECKDOUBLE_PATH); + gdata::shaders_id::ps::idUnionAlpha = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_union_alpha.ps", "pp_union_alpha.ps", SHADER_CHECKDOUBLE_PATH); D3DXMACRO Defines_STR[] = { { "_STR_", "" }, { 0, 0 } }; - GData::IDsShaders::PS::StencilStr = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_alpha_stencil_mark.ps", "pp_stencil_str.ps", SHADER_CHECKDOUBLE_NAME, Defines_STR); + gdata::shaders_id::ps::idStencilStr = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_alpha_stencil_mark.ps", "pp_stencil_str.ps", SHADER_CHECKDOUBLE_NAME, Defines_STR); D3DXMACRO Defines_COLUMN[] = { { "_COLUMN_", "" }, { 0, 0 } }; - GData::IDsShaders::PS::StencilColumn = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_alpha_stencil_mark.ps", "pp_stencil_column.ps", SHADER_CHECKDOUBLE_NAME, Defines_COLUMN); + gdata::shaders_id::ps::idStencilColumn = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_alpha_stencil_mark.ps", "pp_stencil_column.ps", SHADER_CHECKDOUBLE_NAME, Defines_COLUMN); D3DXMACRO Defines_COLUMN_STR[] = { { "_COLUMN_STR_", "" }, { 0, 0 } }; - GData::IDsShaders::PS::StencilStrColumn = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_alpha_stencil_mark.ps", "pp_stencil_str_column.ps", SHADER_CHECKDOUBLE_NAME, Defines_COLUMN_STR); + gdata::shaders_id::ps::idStencilStrColumn = SGCore_ShaderLoad(SHADER_TYPE_PIXEL, "pp_alpha_stencil_mark.ps", "pp_stencil_str_column.ps", SHADER_CHECKDOUBLE_NAME, Defines_COLUMN_STR); } diff --git a/source/render/gdata.h b/source/render/gdata.h index 0de64672834baced60072a098b674f81858ab4a4..7195dc3a5e9f90acd8f5fa949d75da9e98266343 100644 --- a/source/render/gdata.h +++ b/source/render/gdata.h @@ -32,129 +32,124 @@ class CGrid; */ //! пространство имен для хранения данных цикла рендера -namespace GData +namespace gdata { //! dx устройство - extern IDirect3DDevice9* DXDevice; + extern IDirect3DDevice9* pDXDevice; //! хэндл окна родителя окна рендера, на случай редакторов - extern HWND HandleParent3D; + extern HWND hHandleParent3D; //! хэндл окна рендера - extern HWND Handle3D; - - //! использовать ли оконный режим рендера? - //extern bool IsWindowed; - + extern HWND hHandle3D; //!< финальное изображение - extern DS_RT FinalImage; + extern DS_RT typeFinalImage; //!< камера для которой будет рендер - extern ICamera* ObjCamera; + extern ICamera *pCamera; //! id текстуры с цветмо выделения (для редакторов) - extern ID IDSelectTex; + extern ID idSelectTex; //! значение дальней и ближней плоскостей отсечения - extern float2_t NearFar; + extern float2_t vNearFar; //! fov камеры - extern float ProjFov; + extern float fProjFov; //! дефолтный id массива просчетов видимости для геометрии - extern ID DefaultGeomIDArr; + extern ID idDefaultGeomArr; //! дефолтный id массива просчетов видимости для растительности - extern ID DefaultGreenIDArr; + extern ID idDefaultGreenArr; //! дефолтный id массива просчетов видимости для анимационных моделей - extern ID DefaultAnimIDArr; + extern ID idDefaultAnimArr; //! позиция камеры - extern float3 ConstCurrCamPos; + extern float3 vConstCurrCamPos; //! направление взгляда камеры - extern float3 ConstCurrCamDir; + extern float3 vConstCurrCamDir; //! параметры перемещения камеры по умолчанию - extern float4_t CamWalkParamEditor; + extern float4_t vCamWalkParamEditor; //! инициализация матриц void InitAllMatrix(); //! матрица вида камеры - extern float4x4 MCamView; + extern float4x4 mCamView; //! матрица проекции камеры - extern float4x4 MCamProj; + extern float4x4 mCamProj; //! матрица проекции аналогичная камере, только дальнаяя плоскость дальше - extern float4x4 MLightProj; + extern float4x4 mLightProj; //! матрица проекции для рендера skybox и sky clouds, для плоских отражений, аналогична MCamProj - extern float4x4 MRefPlaneSkyProj; + extern float4x4 mRefPlaneSkyProj; //! матрица проекции для рендера skybox и sky clouds, для кубических отражений - extern float4x4 MRefCubeSkyProj; + extern float4x4 mRefCubeSkyProj; //********************************************************************** //! пространство имен с идентификаторами шейдеров - namespace IDsShaders + namespace shaders_id { //! загрузка всех необходимых шейдеров void InitAllShaders(); //! вершинные шейдеры - namespace VS + namespace vs { - extern ID ScreenOut; - extern ID ResPos; + extern ID idScreenOut; + extern ID idResPos; }; //! пиксельные шейдеры - namespace PS + namespace ps { - extern ID ScreenOut; - extern ID ComLightingNonShadow; - extern ID ComLightingShadow; - - extern ID BlendAmbientSpecDiffColor; + extern ID idScreenOut; + extern ID idComLightingNonShadow; + extern ID idComLightingShadow; - //extern ID ToneMapping; + extern ID idBlendAmbientSpecDiffColor; - extern ID StencilStr; - extern ID StencilColumn; - extern ID StencilStrColumn; - extern ID UnionAlpha; + + extern ID idStencilStr; + extern ID idStencilColumn; + extern ID idStencilStrColumn; + extern ID idUnionAlpha; }; }; namespace Editors { //! возможно управлять камерой - extern bool MoveCamera; + extern bool canMoveCamera; //! указатель симуляционной модели - extern CSimulationModel* SimModel; + extern CSimulationModel *pSimModel; //! сетка дял редакторов - extern CGrid* ObjGrid; + extern CGrid *pGrid; //! рендер статический осей в центре координат - extern CAxesStatic* ObjAxesStatic; + extern CAxesStatic *pAxesStatic; - //! рисовать ли #ObjGrid - extern bool RenderGrid; + //! рисовать ли #pGrid + extern bool canRenderGrid; - //! рисовать ли #ObjAxesStatic - extern bool RenderAxesStatic; + //! рисовать ли #pAxesStatic + extern bool canRenderAxesStatic; } }; diff --git a/source/render/render_func.cpp b/source/render/render_func.cpp index cb5d69e905f02b651b7a0250751c5bc4c6857971..5ce1f92ef25cdd7ff21445b7d598c5580dfc012b 100644 --- a/source/render/render_func.cpp +++ b/source/render/render_func.cpp @@ -6,43 +6,43 @@ See the license in LICENSE #include "render_func.h" -inline void SXRenderFunc::SetSamplerFilter(DWORD id, DWORD value) +inline void rfunc::SetSamplerFilter(DWORD dwId, DWORD dwValue) { - GData::DXDevice->SetSamplerState(id, D3DSAMP_MAGFILTER, value); - GData::DXDevice->SetSamplerState(id, D3DSAMP_MINFILTER, value); - GData::DXDevice->SetSamplerState(id, D3DSAMP_MIPFILTER, value); + gdata::pDXDevice->SetSamplerState(dwId, D3DSAMP_MAGFILTER, dwValue); + gdata::pDXDevice->SetSamplerState(dwId, D3DSAMP_MINFILTER, dwValue); + gdata::pDXDevice->SetSamplerState(dwId, D3DSAMP_MIPFILTER, dwValue); } -inline void SXRenderFunc::SetSamplerAddress(DWORD id, DWORD value) +inline void rfunc::SetSamplerAddress(DWORD dwId, DWORD dwValue) { - GData::DXDevice->SetSamplerState(id, D3DSAMP_ADDRESSU, value); - GData::DXDevice->SetSamplerState(id, D3DSAMP_ADDRESSV, value); - GData::DXDevice->SetSamplerState(id, D3DSAMP_ADDRESSW, value); + gdata::pDXDevice->SetSamplerState(dwId, D3DSAMP_ADDRESSU, dwValue); + gdata::pDXDevice->SetSamplerState(dwId, D3DSAMP_ADDRESSV, dwValue); + gdata::pDXDevice->SetSamplerState(dwId, D3DSAMP_ADDRESSW, dwValue); } -inline void SXRenderFunc::SetSamplerFilter(DWORD begin_id, DWORD end_id, DWORD value) +inline void rfunc::SetSamplerFilter(DWORD dwStartId, DWORD dwFinishEnd, DWORD dwValue) { - if (begin_id >= 0 && end_id <= 16) + if (dwStartId >= 0 && dwFinishEnd <= 16) { - for(DWORD i = begin_id; i <= end_id; i++) - SXRenderFunc::SetSamplerFilter(i, value); + for (DWORD i = dwStartId; i <= dwFinishEnd; ++i) + rfunc::SetSamplerFilter(i, dwValue); } } -inline void SXRenderFunc::SetSamplerAddress(DWORD begin_id, DWORD end_id, DWORD value) +inline void rfunc::SetSamplerAddress(DWORD dwStartId, DWORD dwFinishEnd, DWORD dwValue) { - if (begin_id >= 0 && end_id <= 16) + if (dwStartId >= 0 && dwFinishEnd <= 16) { - for (DWORD i = begin_id; i<=end_id; i++) - SXRenderFunc::SetSamplerAddress(i, value); + for (DWORD i = dwStartId; i <= dwFinishEnd; ++i) + rfunc::SetSamplerAddress(i, dwValue); } } -void SXRenderFunc::SetRenderSceneFilter() +void rfunc::SetRenderSceneFilter() { - static const int * r_texfilter_type = GET_PCVAR_INT("r_texfilter_type"); - static const int * r_texfilter_max_anisotropy = GET_PCVAR_INT("r_texfilter_max_anisotropy"); - static const int * r_texfilter_max_miplevel = GET_PCVAR_INT("r_texfilter_max_miplevel"); + static const int *r_texfilter_type = GET_PCVAR_INT("r_texfilter_type"); + static const int *r_texfilter_max_anisotropy = GET_PCVAR_INT("r_texfilter_max_anisotropy"); + static const int *r_texfilter_max_miplevel = GET_PCVAR_INT("r_texfilter_max_miplevel"); static int r_texfilter_type2 = 1; static int r_texfilter_max_anisotropy2 = 0; @@ -62,31 +62,31 @@ void SXRenderFunc::SetRenderSceneFilter() r_texfilter_max_miplevel2 = (*r_texfilter_max_miplevel); else r_texfilter_max_miplevel2 = 1; - + if (r_texfilter_type2 == 0) SetSamplerFilter(0, 16, D3DTEXF_POINT); else if (r_texfilter_type2 == 2) { for (int i = 0; i<16; ++i) - GData::DXDevice->SetSamplerState(i, D3DSAMP_MAXANISOTROPY, r_texfilter_max_anisotropy2); + gdata::pDXDevice->SetSamplerState(i, D3DSAMP_MAXANISOTROPY, r_texfilter_max_anisotropy2); SetSamplerFilter(0, 16, D3DTEXF_ANISOTROPIC); } else SetSamplerFilter(0, 16, D3DTEXF_LINEAR); - GData::DXDevice->SetSamplerState(0, D3DSAMP_MAXMIPLEVEL, r_texfilter_max_miplevel2); + gdata::pDXDevice->SetSamplerState(0, D3DSAMP_MAXMIPLEVEL, r_texfilter_max_miplevel2); SetSamplerAddress(0, 16, D3DTADDRESS_WRAP); } -void SXRenderFunc::SetRenderSceneFilterUn() +void rfunc::SetRenderSceneFilterUn() { - GData::DXDevice->SetSamplerState(0, D3DSAMP_MAXMIPLEVEL, 0); + gdata::pDXDevice->SetSamplerState(0, D3DSAMP_MAXMIPLEVEL, 0); } //########################################################################## -void SXRenderFunc::ComDeviceLost(bool isSetWindowSize) +void rfunc::ComDeviceLost(bool isSetWindowSize) { static int *r_resize = (int*)GET_PCVAR_INT("r_resize"); @@ -98,7 +98,7 @@ void SXRenderFunc::ComDeviceLost(bool isSetWindowSize) { //получаем текущий размер окна в которое рисовали RECT rect_scene; - GetClientRect(GData::Handle3D, &rect_scene); + GetClientRect(gdata::hHandle3D, &rect_scene); *r_win_width = rect_scene.right; *r_win_height = rect_scene.bottom; @@ -107,12 +107,13 @@ void SXRenderFunc::ComDeviceLost(bool isSetWindowSize) //сбрасываем все что необходимо для восстановления устройства SGCore_OnLostDevice(); SGeom_OnLostDevice(); - SML_OnLostDevice(); + SLight_OnLostDevice(); + SMtrl_OnLostDevice(); SPE_OnLostDevice(); SPP_OnLostDevice(); SXGame_OnLostDevice(); - SXRenderFunc::InitModeWindow(); + rfunc::InitModeWindow(); bool bf = SGCore_OnDeviceReset(*r_win_width, *r_win_height, *r_win_windowed); LibReport(REPORT_MSG_LEVEL_WARNING, "r_win_width %d, r_win_height %d, r_win_windowed %d \n", *r_win_width, *r_win_height, *r_win_windowed); @@ -123,89 +124,89 @@ void SXRenderFunc::ComDeviceLost(bool isSetWindowSize) } else { - GData::InitAllMatrix(); + gdata::InitAllMatrix(); *r_resize = RENDER_RESIZE_NONE; SGCore_OnResetDevice(); - SML_OnResetDevice(); + SLight_OnResetDevice(); + SMtrl_OnResetDevice(); SGeom_OnResetDevice(); SPE_OnResetDevice(); SXGame_OnResetDevice(); SPP_OnDeviceReset(); - GData::DXDevice->SetRenderState(D3DRS_LIGHTING, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_LIGHTING, FALSE); } } - -void SXRenderFunc::ComVisibleForLight() +void rfunc::ComVisibleForLight() { - for (int i = 0; igetFrustum()) && SML_LigthsGetEnable(i)) /*|| (Data::Level::LightManager->Arr[i]->ShadowCube && Data::Level::LightManager->Arr[i]->ShadowCube->GetStatic() && !Data::Level::LightManager->Arr[i]->ShadowCube->GetUpdate())*/) + if (SLight_GetShadowed(i) && (SLight_ComVisibleForFrustum(i, gdata::pCamera->getFrustum()) && SLight_GetEnable(i))) { - if (SML_LigthsGetType(i) == LTYPE_LIGHT_GLOBAL) + if (SLight_GetType(i) == LTYPE_LIGHT_GLOBAL) { - for (int k = 0; k<4; k++) + for (int k = 0; k<4; ++k) { - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, k) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_GEOM, k, SGeom_ModelsAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, k) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_GEOM, k, SGeom_ModelsAddArrForCom()); - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, k) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_GREEN, k, SGeom_GreenAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, k) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_GREEN, k, SGeom_GreenAddArrForCom()); - if(SML_LigthsGetIDArr(i, RENDER_IDARRCOM_ANIM, k) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_ANIM, k, SXAnim_ModelsAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_ANIM, k) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_ANIM, k, SXAnim_ModelsAddArrForCom()); - if (SML_LigthsCountUpdateUpdate(i, &GData::ConstCurrCamPos, k)) + if (SLight_CountUpdateUpdate(i, &gdata::vConstCurrCamPos, k)) { - SML_LigthsUpdateGFrustums(i, k, &GData::ConstCurrCamPos, &GData::ConstCurrCamDir); - SGeom_ModelsComVisible(SML_LigthsGetFrustum(i, k), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, k)); - SGeom_GreenComVisible(SML_LigthsGetFrustum(i, k), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, k)); - SXAnim_ModelsComVisible(SML_LigthsGetFrustum(i, k), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_ANIM, k)); + SLight_UpdateGFrustums(i, k, &gdata::vConstCurrCamPos, &gdata::vConstCurrCamDir); + SGeom_ModelsComVisible(SLight_GetFrustum(i, k), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, k)); + SGeom_GreenComVisible(SLight_GetFrustum(i, k), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, k)); + SXAnim_ModelsComVisible(SLight_GetFrustum(i, k), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_ANIM, k)); } } } - else if (SML_LigthsGetType(i) == LTYPE_LIGHT_DIR) + else if (SLight_GetType(i) == LTYPE_LIGHT_DIR) { - if (SML_LigthsGetTypeShadowed(i) == LTYPE_SHADOW_DYNAMIC) + if (SLight_GetTypeShadowed(i) == LTYPE_SHADOW_DYNAMIC) { - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, 0) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_GEOM, 0, SGeom_ModelsAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, 0) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_GEOM, 0, SGeom_ModelsAddArrForCom()); - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, 0) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_GREEN, 0, SGeom_GreenAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, 0) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_GREEN, 0, SGeom_GreenAddArrForCom()); - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_ANIM, 0) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_ANIM, 0, SXAnim_ModelsAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_ANIM, 0) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_ANIM, 0, SXAnim_ModelsAddArrForCom()); - SGeom_ModelsComVisible(SML_LigthsGetFrustum(i, 0), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, 0)); - SGeom_GreenComVisible(SML_LigthsGetFrustum(i, 0), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, 0)); - SXAnim_ModelsComVisible(SML_LigthsGetFrustum(i, 0), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_ANIM, 0)); + SGeom_ModelsComVisible(SLight_GetFrustum(i, 0), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, 0)); + SGeom_GreenComVisible(SLight_GetFrustum(i, 0), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, 0)); + SXAnim_ModelsComVisible(SLight_GetFrustum(i, 0), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_ANIM, 0)); } } - else if (SML_LigthsGetType(i) == LTYPE_LIGHT_POINT) + else if (SLight_GetType(i) == LTYPE_LIGHT_POINT) { - if (SML_LigthsGetTypeShadowed(i) == LTYPE_SHADOW_DYNAMIC) + if (SLight_GetTypeShadowed(i) == LTYPE_SHADOW_DYNAMIC) { for (int k = 0; k < 6; k++) { - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, k) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_GEOM, k, SGeom_ModelsAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, k) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_GEOM, k, SGeom_ModelsAddArrForCom()); - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, k) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_GREEN, k, SGeom_GreenAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, k) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_GREEN, k, SGeom_GreenAddArrForCom()); - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_ANIM, k) <= -1) - SML_LigthsSetIDArr(i, RENDER_IDARRCOM_ANIM, k, SXAnim_ModelsAddArrForCom()); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_ANIM, k) <= -1) + SLight_SetIDArr(i, RENDER_IDARRCOM_ANIM, k, SXAnim_ModelsAddArrForCom()); - if (SML_LigthsGetCubeEdgeEnable(i, k)) + if (SLight_GetCubeEdgeEnable(i, k)) { - SGeom_ModelsComVisible(SML_LigthsGetFrustum(i, k), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, k)); - SGeom_GreenComVisible(SML_LigthsGetFrustum(i, k), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, k)); - SXAnim_ModelsComVisible(SML_LigthsGetFrustum(i, k), &GData::ConstCurrCamPos, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_ANIM, k)); + SGeom_ModelsComVisible(SLight_GetFrustum(i, k), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, k)); + SGeom_GreenComVisible(SLight_GetFrustum(i, k), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, k)); + SXAnim_ModelsComVisible(SLight_GetFrustum(i, k), &gdata::vConstCurrCamPos, SLight_GetIDArr(i, RENDER_IDARRCOM_ANIM, k)); } } } @@ -213,67 +214,67 @@ void SXRenderFunc::ComVisibleForLight() } } - ID tmpidarr = -1; - while (SML_LigthsDelGetCount() > 0) + ID idTempArr = -1; + while (SLight_DelGetCount() > 0) { int iCurrKey = 0; - if (SML_LigthsDelGetType(iCurrKey) == LTYPE_LIGHT_GLOBAL) + if (SLight_DelGetType(iCurrKey) == LTYPE_LIGHT_GLOBAL) { - for (int k = 0; k<4; k++) + for (int k = 0; k<4; ++k) { - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_GEOM, k)) >= 0 && SGeom_ModelsExistsArrForCom(tmpidarr)) - SGeom_ModelsDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_GEOM, k)) >= 0 && SGeom_ModelsExistsArrForCom(idTempArr)) + SGeom_ModelsDelArrForCom(idTempArr); - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_GREEN, k)) >= 0 && SGeom_GreenExistsArrForCom(tmpidarr)) - SGeom_GreenDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_GREEN, k)) >= 0 && SGeom_GreenExistsArrForCom(idTempArr)) + SGeom_GreenDelArrForCom(idTempArr); - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_ANIM, k)) >= 0) - SXAnim_ModelsDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_ANIM, k)) >= 0) + SXAnim_ModelsDelArrForCom(idTempArr); } } - else if (SML_LigthsDelGetType(iCurrKey) == LTYPE_LIGHT_DIR) + else if (SLight_DelGetType(iCurrKey) == LTYPE_LIGHT_DIR) { - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_GEOM, 0)) >= 0 && SGeom_ModelsExistsArrForCom(tmpidarr)) - SGeom_ModelsDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_GEOM, 0)) >= 0 && SGeom_ModelsExistsArrForCom(idTempArr)) + SGeom_ModelsDelArrForCom(idTempArr); - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_GREEN, 0)) >= 0 && SGeom_GreenExistsArrForCom(tmpidarr)) - SGeom_GreenDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_GREEN, 0)) >= 0 && SGeom_GreenExistsArrForCom(idTempArr)) + SGeom_GreenDelArrForCom(idTempArr); - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_ANIM, 0)) >= 0) - SXAnim_ModelsDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_ANIM, 0)) >= 0) + SXAnim_ModelsDelArrForCom(idTempArr); } - else if (SML_LigthsDelGetType(iCurrKey) == LTYPE_LIGHT_POINT) + else if (SLight_DelGetType(iCurrKey) == LTYPE_LIGHT_POINT) { for (int k = 0; k<6; k++) { - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_GEOM, k)) >= 0 && SGeom_ModelsExistsArrForCom(tmpidarr)) - SGeom_ModelsDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_GEOM, k)) >= 0 && SGeom_ModelsExistsArrForCom(idTempArr)) + SGeom_ModelsDelArrForCom(idTempArr); - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_GREEN, k)) >= 0 && SGeom_GreenExistsArrForCom(tmpidarr)) - SGeom_GreenDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_GREEN, k)) >= 0 && SGeom_GreenExistsArrForCom(idTempArr)) + SGeom_GreenDelArrForCom(idTempArr); - if ((tmpidarr = SML_LigthsDelGetIDArr(iCurrKey, RENDER_IDARRCOM_ANIM, k)) >= 0) - SXAnim_ModelsDelArrForCom(tmpidarr); + if ((idTempArr = SLight_DelGetIDArr(iCurrKey, RENDER_IDARRCOM_ANIM, k)) >= 0) + SXAnim_ModelsDelArrForCom(idTempArr); } } - SML_LigthsDelDel(iCurrKey); + SLight_DelDel(iCurrKey); } } -void SXRenderFunc::ComVisibleForCamera() +void rfunc::ComVisibleForCamera() { if (SGeom_ModelsGetCount() > 0) - SGeom_ModelsComVisible(GData::ObjCamera->getFrustum(), &GData::ConstCurrCamPos); + SGeom_ModelsComVisible(gdata::pCamera->getFrustum(), &gdata::vConstCurrCamPos); if (SGeom_GreenGetCount() > 0) - SGeom_GreenComVisible(GData::ObjCamera->getFrustum(), &GData::ConstCurrCamPos); + SGeom_GreenComVisible(gdata::pCamera->getFrustum(), &gdata::vConstCurrCamPos); - SXAnim_ModelsComVisible(GData::ObjCamera->getFrustum(), &GData::ConstCurrCamPos); + SXAnim_ModelsComVisible(gdata::pCamera->getFrustum(), &gdata::vConstCurrCamPos); } -void SXRenderFunc::ComVisibleReflection() +void rfunc::ComVisibleReflection() { static const int *r_reflection_render = GET_PCVAR_INT("r_reflection_render"); @@ -284,90 +285,90 @@ void SXRenderFunc::ComVisibleReflection() { for (int k = 0; k < SGeom_ModelsMGetCountGroups(i); ++k) { - ID idmat = SGeom_ModelsMGetGroupIDMat(i, k); - MTLTYPE_REFLECT typeref = SML_MtlGetTypeReflection(SGeom_ModelsMGetGroupIDMat(i, k)); + ID idMat = SGeom_ModelsMGetGroupIDMat(i, k); + MTLTYPE_REFLECT typeReflection = SMtrl_MtlGetTypeReflection(SGeom_ModelsMGetGroupIDMat(i, k)); float3_t center; - if (typeref == MTLTYPE_REFLECT_PLANE) + if (typeReflection == MTLTYPE_REFLECT_PLANE) { - if (!SML_MtlRefIsAllowedRender(idmat)) + if (!SMtrl_RefIsAllowedRender(idMat)) continue; SGeom_ModelsMGetGroupCenter(i, k, ¢er); - + if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0) < 0) - SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0, SGeom_ModelsAddArrForCom()); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, 0) < 0) + SMtrl_RefSetIDArr(idMat, RENDER_IDARRCOM_GEOM, 0, SGeom_ModelsAddArrForCom()); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0) < 0) - SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0, SGeom_GreenAddArrForCom()); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GREEN, 0) < 0) + SMtrl_RefSetIDArr(idMat, RENDER_IDARRCOM_GREEN, 0, SGeom_GreenAddArrForCom()); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0) < 0) - SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0, SXAnim_ModelsAddArrForCom()); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_ANIM, 0) < 0) + SMtrl_RefSetIDArr(idMat, RENDER_IDARRCOM_ANIM, 0, SXAnim_ModelsAddArrForCom()); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM) - SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0)); + SGeom_ModelsComVisible(SMtrl_RefGetfrustum(idMat, 0), &float3(center), SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, 0)); if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN) - SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0)); - + SGeom_GreenComVisible(SMtrl_RefGetfrustum(idMat, 0), &float3(center), SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GREEN, 0)); + if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM) - SXAnim_ModelsComVisible(SML_MtlRefGetfrustum(idmat, 0), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, 0)); + SXAnim_ModelsComVisible(SMtrl_RefGetfrustum(idMat, 0), &float3(center), SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_ANIM, 0)); } - else if (typeref == MTLTYPE_REFLECT_CUBE_DYNAMIC) + else if (typeReflection == MTLTYPE_REFLECT_CUBE_DYNAMIC) { SGeom_ModelsMGetGroupCenter(i, k, ¢er); - if (!SML_MtlRefIsAllowedRender(idmat)) + if (!SMtrl_RefIsAllowedRender(idMat)) continue; for (int j = 0; j<6; j++) { if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k) < 0) - SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GEOM, k, SGeom_ModelsAddArrForCom()); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, k) < 0) + SMtrl_RefSetIDArr(idMat, RENDER_IDARRCOM_GEOM, k, SGeom_ModelsAddArrForCom()); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k) < 0) - SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_GREEN, k, SGeom_GreenAddArrForCom()); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GREEN, k) < 0) + SMtrl_RefSetIDArr(idMat, RENDER_IDARRCOM_GREEN, k, SGeom_GreenAddArrForCom()); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, k) < 0) - SML_MtlRefSetIDArr(idmat, RENDER_IDARRCOM_ANIM, k, SXAnim_ModelsAddArrForCom()); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_ANIM, k) < 0) + SMtrl_RefSetIDArr(idMat, RENDER_IDARRCOM_ANIM, k, SXAnim_ModelsAddArrForCom()); } - + if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM) - SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k)); - + SGeom_ModelsComVisible(SMtrl_RefGetfrustum(idMat, j), &float3(center), SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, k)); + if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN) - SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k)); - + SGeom_GreenComVisible(SMtrl_RefGetfrustum(idMat, j), &float3(center), SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, k)); + if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM) - SXAnim_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_ANIM, k)); + SXAnim_ModelsComVisible(SMtrl_RefGetfrustum(idMat, j), &float3(center), SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_ANIM, k)); } } } } } -void SXRenderFunc::SaveScreenShot() +void rfunc::SaveScreenShot() { char tmppath[1024]; static int numscreen = 0; - + if (!FileExistsFile(Core_RStringGet(G_RI_STRING_PATH_SCREENSHOTS))) { CreateDirectoryA(Core_RStringGet(G_RI_STRING_PATH_SCREENSHOTS), NULL); @@ -380,66 +381,66 @@ void SXRenderFunc::SaveScreenShot() } while (FileExistsFile(tmppath)); LPDIRECT3DSURFACE9 BackBuf; - GData::DXDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &BackBuf); + gdata::pDXDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &BackBuf); D3DXSaveSurfaceToFile(tmppath, D3DXIFF_JPG, BackBuf, NULL, NULL); mem_release(BackBuf); } -void SXRenderFunc::SaveWorkTex() +void rfunc::SaveWorkTex() { char tmppath[1024]; sprintf(tmppath, "%scolor.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_COLOR), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_COLOR), NULL); sprintf(tmppath, "%snormal.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_NORMAL), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_NORMAL), NULL); sprintf(tmppath, "%sdepth.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_DEPTH), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_DEPTH), NULL); sprintf(tmppath, "%sdepth0.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_DEPTH0), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_DEPTH0), NULL); sprintf(tmppath, "%sparam.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_PARAM), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_PARAM), NULL); sprintf(tmppath, "%sambient_diff.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_AMBIENTDIFF), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_AMBIENTDIFF), NULL); sprintf(tmppath, "%sspecular.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_SPECULAR), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_SPECULAR), NULL); sprintf(tmppath, "%slight_com_1.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_SCENELIGHT), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_SCENELIGHT), NULL); sprintf(tmppath, "%slight_com_2.png", Core_RStringGet(G_RI_STRING_PATH_WORKTEX)); - D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SML_DSGetRT(DS_RT_SCENELIGHT2), NULL); + D3DXSaveTextureToFile(tmppath, D3DXIFF_PNG, SGCore_GbufferGetRT(DS_RT_SCENELIGHT2), NULL); } -void SXRenderFunc::InitModeWindow() +void rfunc::InitModeWindow() { static int * r_win_width = (int*)GET_PCVAR_INT("r_win_width"); static int * r_win_height = (int*)GET_PCVAR_INT("r_win_height"); static const bool *r_win_windowed = GET_PCVAR_BOOL("r_win_windowed"); - static DWORD dwStyle = GetWindowLong(GData::Handle3D, GWL_STYLE); + static DWORD dwStyle = GetWindowLong(gdata::hHandle3D, GWL_STYLE); if (r_win_windowed == NULL) return; if (!(*r_win_windowed)) { - SetWindowLong(GData::Handle3D, GWL_STYLE, dwStyle | WS_POPUP); - ShowWindow(GData::Handle3D, SW_MAXIMIZE); + SetWindowLong(gdata::hHandle3D, GWL_STYLE, dwStyle | WS_POPUP); + ShowWindow(gdata::hHandle3D, SW_MAXIMIZE); } else { - SetWindowLong(GData::Handle3D, GWL_STYLE, dwStyle); + SetWindowLong(gdata::hHandle3D, GWL_STYLE, dwStyle); /*RECT rc; - GetWindowRect(GData::Handle3D, &rc);*/ + GetWindowRect(gdata::hHandle3D, &rc);*/ RECT rc2 = { 0, 0, *r_win_width, *r_win_height }; AdjustWindowRect(&rc2, dwStyle, false); @@ -448,22 +449,14 @@ void SXRenderFunc::InitModeWindow() int iHeight = rc2.bottom - rc2.top; int iPosX = (GetSystemMetrics(SM_CXSCREEN) - iWidth) / 2; int iPosY = (GetSystemMetrics(SM_CYSCREEN) - iHeight) / 2; - SetWindowPos(GData::Handle3D, HWND_NOTOPMOST, iPosX, iPosY, iWidth, iHeight, SWP_SHOWWINDOW); + SetWindowPos(gdata::hHandle3D, HWND_NOTOPMOST, iPosX, iPosY, iWidth, iHeight, SWP_SHOWWINDOW); - SetForegroundWindow(GData::Handle3D); + SetForegroundWindow(gdata::hHandle3D); } } -void SXRenderFunc::ChangeModeWindow() +void rfunc::ChangeModeWindow() { - /*static int * r_win_width = (int*)GET_PCVAR_INT("r_win_width"); - *r_win_width = 1280; - - static int * r_win_height = (int*)GET_PCVAR_INT("r_win_height"); - *r_win_height = 768; - - return;*/ - static bool *r_win_windowed = (bool*)GET_PCVAR_BOOL("r_win_windowed"); if (r_win_windowed == NULL) @@ -471,13 +464,13 @@ void SXRenderFunc::ChangeModeWindow() *r_win_windowed = !(*r_win_windowed); - SXRenderFunc::InitModeWindow(); + rfunc::InitModeWindow(); static int *r_resize = (int*)GET_PCVAR_INT("r_resize"); *r_resize = RENDER_RESIZE_CHANGE; } -void SXRenderFunc::FullScreenChangeSizeAbs() +void rfunc::FullScreenChangeSizeAbs() { static bool *r_win_windowed = (bool*)GET_PCVAR_BOOL("r_win_windowed"); @@ -528,54 +521,54 @@ void SXRenderFunc::FullScreenChangeSizeAbs() //########################################################################## -void SXRenderFunc::UpdateView() +void rfunc::UpdateView() { - GData::InitAllMatrix(); + gdata::InitAllMatrix(); + + gdata::pCamera->getViewMatrix(&gdata::mCamView); - GData::ObjCamera->getViewMatrix(&GData::MCamView); - Core_RMatrixSet(G_RI_MATRIX_WORLD, &SMMatrixIdentity()); - Core_RMatrixSet(G_RI_MATRIX_VIEW, &GData::MCamView); - Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MLightProj); - Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &(GData::MCamView * GData::MLightProj)); - Core_RMatrixSet(G_RI_MATRIX_TRANSP_VIEWPROJ, &SMMatrixTranspose(GData::MCamView * GData::MLightProj)); + Core_RMatrixSet(G_RI_MATRIX_VIEW, &gdata::mCamView); + Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &gdata::mLightProj); + Core_RMatrixSet(G_RI_MATRIX_VIEWPROJ, &(gdata::mCamView * gdata::mLightProj)); + Core_RMatrixSet(G_RI_MATRIX_TRANSP_VIEWPROJ, &SMMatrixTranspose(gdata::mCamView * gdata::mLightProj)); - GData::ObjCamera->getPosition(&GData::ConstCurrCamPos); - GData::ObjCamera->getLook(&GData::ConstCurrCamDir); + gdata::pCamera->getPosition(&gdata::vConstCurrCamPos); + gdata::pCamera->getLook(&gdata::vConstCurrCamDir); - Core_RFloat3Set(G_RI_FLOAT3_OBSERVER_POSITION, &GData::ConstCurrCamPos); - Core_RFloat3Set(G_RI_FLOAT3_OBSERVER_DIRECTION, &GData::ConstCurrCamDir); + Core_RFloat3Set(G_RI_FLOAT3_OBSERVER_POSITION, &gdata::vConstCurrCamPos); + Core_RFloat3Set(G_RI_FLOAT3_OBSERVER_DIRECTION, &gdata::vConstCurrCamDir); - Core_RMatrixSet(G_RI_MATRIX_OBSERVER_VIEW, &GData::MCamView); - Core_RMatrixSet(G_RI_MATRIX_OBSERVER_PROJ, &GData::MCamProj); - Core_RMatrixSet(G_RI_MATRIX_LIGHT_PROJ, &GData::MLightProj); + Core_RMatrixSet(G_RI_MATRIX_OBSERVER_VIEW, &gdata::mCamView); + Core_RMatrixSet(G_RI_MATRIX_OBSERVER_PROJ, &gdata::mCamProj); + Core_RMatrixSet(G_RI_MATRIX_LIGHT_PROJ, &gdata::mLightProj); - /*Core_RFloatSet(G_RI_FLOAT_OBSERVER_NEAR, GData::NearFar.x); - Core_RFloatSet(G_RI_FLOAT_OBSERVER_FAR, GData::NearFar.y); - Core_RFloatSet(G_RI_FLOAT_OBSERVER_FOV, GData::ProjFov);*/ + /*Core_RFloatSet(G_RI_FLOAT_OBSERVER_NEAR, gdata::vNearFar.x); + Core_RFloatSet(G_RI_FLOAT_OBSERVER_FAR, gdata::vNearFar.y); + Core_RFloatSet(G_RI_FLOAT_OBSERVER_FOV, gdata::fProjFov);*/ - GData::ObjCamera->updateFrustum(&GData::MCamProj); + gdata::pCamera->updateFrustum(&gdata::mCamProj); - if (GData::DefaultGeomIDArr < 0) - GData::DefaultGeomIDArr = SGeom_ModelsAddArrForCom(); + if (gdata::idDefaultGeomArr < 0) + gdata::idDefaultGeomArr = SGeom_ModelsAddArrForCom(); - if (GData::DefaultGreenIDArr < 0) - GData::DefaultGreenIDArr = SGeom_GreenAddArrForCom(); + if (gdata::idDefaultGreenArr < 0) + gdata::idDefaultGreenArr = SGeom_GreenAddArrForCom(); - if (GData::DefaultAnimIDArr < 0) - GData::DefaultAnimIDArr = SXAnim_ModelsAddArrForCom(); + if (gdata::idDefaultAnimArr < 0) + gdata::idDefaultAnimArr = SXAnim_ModelsAddArrForCom(); } -int SXRenderFunc::OutputDebugInfo(DWORD timeDelta, bool needGameTime, const char *szStr) +int rfunc::OutputDebugInfo(DWORD timeDelta, bool needGameTime, const char *szStr) { - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); static int FrameCount = 0; static int FrameCount2 = 0; - static float TimeElapsed=0; + static float TimeElapsed = 0; static float FpsValue = 0; static char FpsStr[1024]; static char debugstr[SXGC_STR_SIZE_DBG_MSG]; @@ -585,7 +578,7 @@ int SXRenderFunc::OutputDebugInfo(DWORD timeDelta, bool needGameTime, const char static const int * r_stats = GET_PCVAR_INT("r_stats"); static bool isNulled = false; - + if (TimeElapsed >= 1.0f && r_stats) { FpsValue = (float)FrameCount / TimeElapsed; @@ -617,7 +610,7 @@ int SXRenderFunc::OutputDebugInfo(DWORD timeDelta, bool needGameTime, const char } else isNulled = false; - + if (r_stats && (*r_stats) > 0) SGCore_DbgMsg(debugstr); @@ -626,7 +619,7 @@ int SXRenderFunc::OutputDebugInfo(DWORD timeDelta, bool needGameTime, const char //########################################################################## -void SXRenderFunc::BuildMRT(DWORD timeDelta, bool isRenderSimulation) +void rfunc::BuildMRT(DWORD timeDelta, bool isRenderSimulation) { static const int *r_win_width = GET_PCVAR_INT("r_win_width"); static const int *r_win_height = GET_PCVAR_INT("r_win_height"); @@ -636,46 +629,46 @@ void SXRenderFunc::BuildMRT(DWORD timeDelta, bool isRenderSimulation) SGCore_ShaderUnBind(); Core_RIntSet(G_RI_INT_RENDERSTATE, RENDER_STATE_MATERIAL); - + Core_RMatrixGet(G_RI_MATRIX_WORLD, &SMMatrixIdentity()); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - SXRenderFunc::SetRenderSceneFilter(); + rfunc::SetRenderSceneFilter(); LPDIRECT3DSURFACE9 BackBuf, ColorSurf, NormalSurf, ParamSurf, DepthMapLinearSurf; - SML_DSGetRT(DS_RT_COLOR)->GetSurfaceLevel(0, &ColorSurf); - SML_DSGetRT(DS_RT_NORMAL)->GetSurfaceLevel(0, &NormalSurf); - SML_DSGetRT(DS_RT_PARAM)->GetSurfaceLevel(0, &ParamSurf); - SML_DSGetRT(DS_RT_DEPTH)->GetSurfaceLevel(0, &DepthMapLinearSurf); + SGCore_GbufferGetRT(DS_RT_COLOR)->GetSurfaceLevel(0, &ColorSurf); + SGCore_GbufferGetRT(DS_RT_NORMAL)->GetSurfaceLevel(0, &NormalSurf); + SGCore_GbufferGetRT(DS_RT_PARAM)->GetSurfaceLevel(0, &ParamSurf); + SGCore_GbufferGetRT(DS_RT_DEPTH)->GetSurfaceLevel(0, &DepthMapLinearSurf); //очищаем рт глубины максимальным значением //чтобы там где нет окружения к примеру был скайбокс, а значит в рт глубины было максимальное значение - максимальная отдаленность - GData::DXDevice->SetRenderTarget(3, DepthMapLinearSurf); - GData::DXDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(255, 255, 255, 255), 1.0f, 0); - GData::DXDevice->SetRenderTarget(3, 0); //убираем рт глубины + gdata::pDXDevice->SetRenderTarget(3, DepthMapLinearSurf); + gdata::pDXDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(255, 255, 255, 255), 1.0f, 0); + gdata::pDXDevice->SetRenderTarget(3, 0); //убираем рт глубины - GData::DXDevice->SetRenderTarget(1, NormalSurf); - GData::DXDevice->SetRenderTarget(2, ParamSurf); - GData::DXDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); - GData::DXDevice->SetRenderTarget(1, 0); - GData::DXDevice->SetRenderTarget(2, 0); + gdata::pDXDevice->SetRenderTarget(1, NormalSurf); + gdata::pDXDevice->SetRenderTarget(2, ParamSurf); + gdata::pDXDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); + gdata::pDXDevice->SetRenderTarget(1, 0); + gdata::pDXDevice->SetRenderTarget(2, 0); - GData::DXDevice->GetRenderTarget(0, &BackBuf); - GData::DXDevice->SetRenderTarget(0, ColorSurf); - GData::DXDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, RENDER_DEFAUL_BACKGROUND_COLOR/*D3DCOLOR_ARGB(0, 0, 0, 0)*/, 1.0f, 0); - - GData::DXDevice->SetRenderTarget(1, NormalSurf); - GData::DXDevice->SetRenderTarget(2, ParamSurf); - GData::DXDevice->SetRenderTarget(3, DepthMapLinearSurf); //ставим рт глубины + gdata::pDXDevice->GetRenderTarget(0, &BackBuf); + gdata::pDXDevice->SetRenderTarget(0, ColorSurf); + gdata::pDXDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, RENDER_DEFAUL_BACKGROUND_COLOR/*D3DCOLOR_ARGB(0, 0, 0, 0)*/, 1.0f, 0); - SML_MtlNullingCurrCountSurf(); - SML_MtlSetCurrCountSurf(RENDER_LAYER_UNTRANSPARENT); + gdata::pDXDevice->SetRenderTarget(1, NormalSurf); + gdata::pDXDevice->SetRenderTarget(2, ParamSurf); + gdata::pDXDevice->SetRenderTarget(3, DepthMapLinearSurf); //ставим рт глубины + + SMtrl_MtlNullingCurrCountSurf(); + SMtrl_MtlSetCurrCountSurf(RENDER_LAYER_UNTRANSPARENT); if (!isRenderSimulation) @@ -687,7 +680,7 @@ void SXRenderFunc::BuildMRT(DWORD timeDelta, bool isRenderSimulation) SXAnim_Render(); if (SGeom_GreenGetCount() > 0) - SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_ALL); + SGeom_GreenRender(timeDelta, &gdata::vConstCurrCamPos, GREEN_TYPE_ALL); SGCore_ShaderUnBind(); } @@ -695,39 +688,39 @@ void SXRenderFunc::BuildMRT(DWORD timeDelta, bool isRenderSimulation) //копируем глубину нулевого слоя (непрозрачной геометрии) в рт непрозрачной глубины //{ //mem_release_del(DepthMapLinearSurf); - //GData::DXDevice->SetRenderTarget(0, BackBuf); - GData::DXDevice->SetRenderTarget(1, 0); - GData::DXDevice->SetRenderTarget(2, 0); - GData::DXDevice->SetRenderTarget(3, 0); + //gdata::pDXDevice->SetRenderTarget(0, BackBuf); + gdata::pDXDevice->SetRenderTarget(1, 0); + gdata::pDXDevice->SetRenderTarget(2, 0); + gdata::pDXDevice->SetRenderTarget(3, 0); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); SGCore_SetSamplerFilter(0, D3DTEXF_NONE); SGCore_SetSamplerAddress(0, D3DTADDRESS_CLAMP); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); LPDIRECT3DSURFACE9 DepthSurf2; - SML_DSGetRT(DS_RT_DEPTH0)->GetSurfaceLevel(0, &DepthSurf2); + SGCore_GbufferGetRT(DS_RT_DEPTH0)->GetSurfaceLevel(0, &DepthSurf2); - GData::DXDevice->SetRenderTarget(0, DepthSurf2); + gdata::pDXDevice->SetRenderTarget(0, DepthSurf2); - GData::DXDevice->SetTexture(0, SML_DSGetRT(DS_RT_DEPTH)); + gdata::pDXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_DEPTH)); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::ScreenOut); + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idScreenOut); SGCore_ScreenQuadDraw(); - SXRenderFunc::SetRenderSceneFilter(); - //SML_DSGetRT(DS_RT_DEPTH)->GetSurfaceLevel(0, &DepthMapLinearSurf); - GData::DXDevice->SetRenderTarget(0, ColorSurf); - GData::DXDevice->SetRenderTarget(1, NormalSurf); - GData::DXDevice->SetRenderTarget(2, ParamSurf); - GData::DXDevice->SetRenderTarget(3, DepthMapLinearSurf); + rfunc::SetRenderSceneFilter(); + //SGCore_GbufferGetRT(DS_RT_DEPTH)->GetSurfaceLevel(0, &DepthMapLinearSurf); + gdata::pDXDevice->SetRenderTarget(0, ColorSurf); + gdata::pDXDevice->SetRenderTarget(1, NormalSurf); + gdata::pDXDevice->SetRenderTarget(2, ParamSurf); + gdata::pDXDevice->SetRenderTarget(3, DepthMapLinearSurf); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); mem_release_del(DepthSurf2); //}} @@ -746,99 +739,99 @@ void SXRenderFunc::BuildMRT(DWORD timeDelta, bool isRenderSimulation) //второй случай логичнее, однако на двух дальних плоскостях иногда наблюдается переход одной плоскости на передний план, что слегка заметно //пересмотреть этот момент как будет время, а пока оставить второй вариант как наиболее логичный - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, FALSE); - GData::DXDevice->Clear(0, 0, D3DCLEAR_STENCIL, 0, 1.0f, 0); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, FALSE); + gdata::pDXDevice->Clear(0, 0, D3DCLEAR_STENCIL, 0, 1.0f, 0); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS); - GData::DXDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS); - GData::DXDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP); - GData::DXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE); + gdata::pDXDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE); - GData::DXDevice->SetRenderState(D3DRS_STENCILREF, 1); - GData::DXDevice->SetRenderState(D3DRS_STENCILMASK, 0xFFFFFFFF); - GData::DXDevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xFFFFFFFF); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILREF, 1); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILMASK, 0xFFFFFFFF); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xFFFFFFFF); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::StencilStr); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::StencilStr, "g_vWinSize", &vWinSize); + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idStencilStr); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idStencilStr, "g_vWinSize", &vWinSize); SGCore_ScreenQuadDraw(); - GData::DXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE); - GData::DXDevice->SetRenderState(D3DRS_STENCILREF, 2); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILREF, 2); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::StencilColumn); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::StencilColumn, "g_vWinSize", &vWinSize); + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idStencilColumn); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idStencilColumn, "g_vWinSize", &vWinSize); SGCore_ScreenQuadDraw(); - GData::DXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE); - GData::DXDevice->SetRenderState(D3DRS_STENCILREF, 3); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILREF, 3); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::StencilStrColumn); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::StencilStrColumn, "g_vWinSize", &vWinSize); + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idStencilStrColumn); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idStencilStrColumn, "g_vWinSize", &vWinSize); SGCore_ScreenQuadDraw(); - GData::DXDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP); - GData::DXDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP); - GData::DXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); - GData::DXDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); SGCore_ShaderUnBind(); - SML_MtlSetForceblyAlphaTest(true); + SMtrl_MtlSetForceblyAlphaTest(true); - GData::DXDevice->SetRenderState(D3DRS_STENCILREF, 0); - GData::DXDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_NOTEQUAL); - GData::DXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_DECR); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILREF, 0); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_NOTEQUAL); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_DECR); if (SGeom_ModelsGetCount() > 0) { - SML_MtlSetIsIncrCountSurf(true); - SML_MtlSetCurrCountSurf(RENDER_LAYER_TRANSPARENT); + SMtrl_MtlSetIsIncrCountSurf(true); + SMtrl_MtlSetCurrCountSurf(RENDER_LAYER_TRANSPARENT); SGeom_ModelsRender(timeDelta, MTLTYPE_TRANSPARENCY, 0, true); } - SML_MtlSetForceblyAlphaTest(false); - GData::DXDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); + SMtrl_MtlSetForceblyAlphaTest(false); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); SGCore_ShaderUnBind(); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); } SXDecals_Render(); } else { - if (SML_MtlGetSort(GData::Editors::SimModel->getIdMtl()) != MTLSORT_OPAQUE) - SML_MtlSetForceblyAlphaTest(true); - GData::Editors::SimModel->render(timeDelta); - if (SML_MtlGetSort(GData::Editors::SimModel->getIdMtl()) != MTLSORT_OPAQUE) - SML_MtlSetForceblyAlphaTest(false); + if (SMtrl_MtlGetSort(gdata::Editors::pSimModel->getIdMtl()) != MTLSORT_OPAQUE) + SMtrl_MtlSetForceblyAlphaTest(true); + gdata::Editors::pSimModel->render(timeDelta); + if (SMtrl_MtlGetSort(gdata::Editors::pSimModel->getIdMtl()) != MTLSORT_OPAQUE) + SMtrl_MtlSetForceblyAlphaTest(false); } - GData::DXDevice->SetRenderTarget(0, BackBuf); - GData::DXDevice->SetRenderTarget(1, 0); - GData::DXDevice->SetRenderTarget(2, 0); - GData::DXDevice->SetRenderTarget(3, 0); + gdata::pDXDevice->SetRenderTarget(0, BackBuf); + gdata::pDXDevice->SetRenderTarget(1, 0); + gdata::pDXDevice->SetRenderTarget(2, 0); + gdata::pDXDevice->SetRenderTarget(3, 0); mem_release(BackBuf); @@ -847,188 +840,188 @@ void SXRenderFunc::BuildMRT(DWORD timeDelta, bool isRenderSimulation) mem_release(ParamSurf); mem_release(DepthMapLinearSurf); - SXRenderFunc::SetRenderSceneFilterUn(); + rfunc::SetRenderSceneFilterUn(); } -void SXRenderFunc::UpdateShadow(DWORD timeDelta) +void rfunc::UpdateShadow(DWORD timeDelta) { Core_RIntSet(G_RI_INT_RENDERSTATE, RENDER_STATE_SHADOW); - SML_LigthsComVisibleFrustumDistFor(GData::ObjCamera->getFrustum(), &GData::ConstCurrCamPos); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + SLight_ComVisibleFrustumDistFor(gdata::pCamera->getFrustum(), &gdata::vConstCurrCamPos); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); SetSamplerFilter(0, D3DTEXF_LINEAR); SetSamplerAddress(0, D3DTADDRESS_WRAP); - GData::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED); + gdata::pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED); - for (int i = 0; igetFrustum()) && SML_LigthsGetEnable(i)) /*|| (Data::Level::LightManager->Arr[i]->ShadowCube && Data::Level::LightManager->Arr[i]->ShadowCube->GetStatic() && !Data::Level::LightManager->Arr[i]->ShadowCube->GetUpdate())*/) + if (SLight_GetShadowed(i) && (SLight_ComVisibleForFrustum(i, gdata::pCamera->getFrustum()) && SLight_GetEnable(i)) /*|| (Data::Level::LightManager->Arr[i]->ShadowCube && Data::Level::LightManager->Arr[i]->ShadowCube->GetStatic() && !Data::Level::LightManager->Arr[i]->ShadowCube->GetUpdate())*/) { - if (SML_LigthsGetType(i) == LTYPE_LIGHT_GLOBAL) + if (SLight_GetType(i) == LTYPE_LIGHT_GLOBAL) { - SML_LigthsShadowRenderBegin(i); - int countsplits = (SML_LigthsGet4Or3SplitsG(i) ? 4 : 3); - for (int k = 0; k -1) - SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, k)); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, k) > -1) + SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, k)); - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, k) > -1) - SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_TREE, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, k)); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, k) > -1) + SGeom_GreenRender(timeDelta, &gdata::vConstCurrCamPos, GREEN_TYPE_TREE, SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, k)); - SXAnim_Render(); - } + SXAnim_Render(); } + } //КОГДА ИСТОЧНИК БЛИЗОК К ГОРИЗОНТУ ИЗ-ЗА ОБЛАКОВ ВОЗНИКАЕТ БАГ С ТЕНЯМИ В ВИДЕ ФЕЙКОВЫХ ТЕНЕЙ if (SGCore_SkyCloudsIsCr()) { - SML_LigthsUpdateGFrustums(i, 4, &GData::ConstCurrCamPos, &GData::ConstCurrCamDir); - SML_LigthsShadowRenderPre(i, 4); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + SLight_UpdateGFrustums(i, 4, &gdata::vConstCurrCamPos, &gdata::vConstCurrCamDir); + SLight_ShadowRenderPre(i, 4); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); SetSamplerFilter(0, D3DTEXF_LINEAR); SetSamplerFilter(1, D3DTEXF_LINEAR); SetSamplerAddress(0, D3DTADDRESS_MIRROR); SetSamplerAddress(1, D3DTADDRESS_MIRROR); if (SGCore_SkyCloudsIsLoadTex()) - SGCore_SkyCloudsRender(timeDelta, &float3(GData::ConstCurrCamPos.x, GData::ConstCurrCamPos.y + 150, GData::ConstCurrCamPos.z), true); + SGCore_SkyCloudsRender(timeDelta, &float3(gdata::vConstCurrCamPos.x, gdata::vConstCurrCamPos.y + 150, gdata::vConstCurrCamPos.z), true); else - GData::DXDevice->Clear(0, 0, D3DCLEAR_TARGET, 0, 1.0f, 0); + gdata::pDXDevice->Clear(0, 0, D3DCLEAR_TARGET, 0, 1.0f, 0); SetSamplerAddress(0, D3DTADDRESS_WRAP); SetSamplerAddress(1, D3DTADDRESS_WRAP); } - SML_LigthsShadowRenderEnd(i); + SLight_ShadowRenderEnd(i); } - else if (SML_LigthsGetType(i) == LTYPE_LIGHT_DIR) + else if (SLight_GetType(i) == LTYPE_LIGHT_DIR) { - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - if (SML_LigthsCountUpdateUpdate(i, &GData::ConstCurrCamPos)) + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + if (SLight_CountUpdateUpdate(i, &gdata::vConstCurrCamPos)) { - SML_LigthsShadowRenderBegin(i); + SLight_ShadowRenderBegin(i); - if (SML_LigthsGetTypeShadowed(i) == LTYPE_SHADOW_DYNAMIC) + if (SLight_GetTypeShadowed(i) == LTYPE_SHADOW_DYNAMIC) { - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, 0) > -1) - SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, 0)); - - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, 0) > -1) - SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_TREE, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, 0)); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, 0) > -1) + SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, 0)); + + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, 0) > -1) + SGeom_GreenRender(timeDelta, &gdata::vConstCurrCamPos, GREEN_TYPE_TREE, SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, 0)); SXAnim_Render(); } else { - SGeom_ModelsComVisible(SML_LigthsGetFrustum(i, 0), &GData::ConstCurrCamPos, GData::DefaultGeomIDArr); - SGeom_ModelsRender(timeDelta, -1, GData::DefaultGeomIDArr); - SGeom_GreenComVisible(SML_LigthsGetFrustum(i, 0), &GData::ConstCurrCamPos, GData::DefaultGreenIDArr); - SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_TREE, GData::DefaultGreenIDArr); + SGeom_ModelsComVisible(SLight_GetFrustum(i, 0), &gdata::vConstCurrCamPos, gdata::idDefaultGeomArr); + SGeom_ModelsRender(timeDelta, -1, gdata::idDefaultGeomArr); + SGeom_GreenComVisible(SLight_GetFrustum(i, 0), &gdata::vConstCurrCamPos, gdata::idDefaultGreenArr); + SGeom_GreenRender(timeDelta, &gdata::vConstCurrCamPos, GREEN_TYPE_TREE, gdata::idDefaultGreenArr); } - SML_LigthsShadowRenderEnd(i); + SLight_ShadowRenderEnd(i); } } - else if (SML_LigthsGetType(i) == LTYPE_LIGHT_POINT) + else if (SLight_GetType(i) == LTYPE_LIGHT_POINT) { - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - if (SML_LigthsGetTypeShadowed(i) != LTYPE_SHADOW_NONE && SML_LigthsCountUpdateUpdate(i, &GData::ConstCurrCamPos)) + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + if (SLight_GetTypeShadowed(i) != LTYPE_SHADOW_NONE && SLight_CountUpdateUpdate(i, &gdata::vConstCurrCamPos)) { - SML_LigthsShadowRenderBegin(i); + SLight_ShadowRenderBegin(i); for (int k = 0; k < 6; k++) { - if (SML_LigthsGetCubeEdgeEnable(i, k)) + if (SLight_GetCubeEdgeEnable(i, k)) { - SML_LigthsShadowRenderPre(i, k); + SLight_ShadowRenderPre(i, k); - if (SML_LigthsGetTypeShadowed(i) == LTYPE_SHADOW_DYNAMIC) + if (SLight_GetTypeShadowed(i) == LTYPE_SHADOW_DYNAMIC) { - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, k) > -1) - SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GEOM, k)); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, k) > -1) + SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SLight_GetIDArr(i, RENDER_IDARRCOM_GEOM, k)); - if (SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, k) > -1) - SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_TREE, SML_LigthsGetIDArr(i, RENDER_IDARRCOM_GREEN, k)); + if (SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, k) > -1) + SGeom_GreenRender(timeDelta, &gdata::vConstCurrCamPos, GREEN_TYPE_TREE, SLight_GetIDArr(i, RENDER_IDARRCOM_GREEN, k)); SXAnim_Render(); } else { - SGeom_ModelsComVisible(SML_LigthsGetFrustum(i, k), &GData::ConstCurrCamPos, GData::DefaultGeomIDArr); - SGeom_ModelsRender(timeDelta, -1, GData::DefaultGeomIDArr); - SGeom_GreenComVisible(SML_LigthsGetFrustum(i, k), &GData::ConstCurrCamPos, GData::DefaultGreenIDArr); - SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_TREE, GData::DefaultGreenIDArr); + SGeom_ModelsComVisible(SLight_GetFrustum(i, k), &gdata::vConstCurrCamPos, gdata::idDefaultGeomArr); + SGeom_ModelsRender(timeDelta, -1, gdata::idDefaultGeomArr); + SGeom_GreenComVisible(SLight_GetFrustum(i, k), &gdata::vConstCurrCamPos, gdata::idDefaultGreenArr); + SGeom_GreenRender(timeDelta, &gdata::vConstCurrCamPos, GREEN_TYPE_TREE, gdata::idDefaultGreenArr); } - - SML_LigthsShadowRenderPost(i, k); + + SLight_ShadowRenderPost(i, k); } } - SML_LigthsShadowRenderEnd(i); + SLight_ShadowRenderEnd(i); } } } } Core_RIntSet(G_RI_INT_RENDERSTATE, RENDER_STATE_FREE); - GData::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW); + gdata::pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW); } -void SXRenderFunc::RenderSky(DWORD timeDelta) +void rfunc::RenderSky(DWORD timeDelta) { LPDIRECT3DSURFACE9 ColorSurf, BackBuf; - SML_DSGetRT(DS_RT_SCENELIGHT)->GetSurfaceLevel(0, &ColorSurf); - GData::DXDevice->GetRenderTarget(0, &BackBuf); - GData::DXDevice->SetRenderTarget(0, ColorSurf); + SGCore_GbufferGetRT(DS_RT_SCENELIGHT)->GetSurfaceLevel(0, &ColorSurf); + gdata::pDXDevice->GetRenderTarget(0, &BackBuf); + gdata::pDXDevice->SetRenderTarget(0, ColorSurf); - GData::DXDevice->Clear(0, 0, D3DCLEAR_TARGET, RENDER_DEFAUL_BACKGROUND_COLOR, 1.0f, 0); + gdata::pDXDevice->Clear(0, 0, D3DCLEAR_TARGET, RENDER_DEFAUL_BACKGROUND_COLOR, 1.0f, 0); SetSamplerFilter(0, 2, D3DTEXF_ANISOTROPIC); if (SGCore_SkyBoxIsCr() && SGCore_SkyBoxIsLoadTex()) { - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); SetSamplerAddress(0, 2, D3DTADDRESS_CLAMP); - SGCore_SkyBoxRender(timeDelta, &float3(GData::ConstCurrCamPos.x, GData::ConstCurrCamPos.y + 40, GData::ConstCurrCamPos.z)); + SGCore_SkyBoxRender(timeDelta, &float3(gdata::vConstCurrCamPos.x, gdata::vConstCurrCamPos.y + 40, gdata::vConstCurrCamPos.z)); } - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); - GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); + gdata::pDXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); + gdata::pDXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); - GData::DXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); - GData::DXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); if (SGCore_SkyCloudsIsCr() && SGCore_SkyCloudsIsLoadTex()) { SetSamplerAddress(0, 2, D3DTADDRESS_MIRROR); - SGCore_SkyCloudsRender(timeDelta, &float3(GData::ConstCurrCamPos.x, GData::ConstCurrCamPos.y + 150, GData::ConstCurrCamPos.z), false); + SGCore_SkyCloudsRender(timeDelta, &float3(gdata::vConstCurrCamPos.x, gdata::vConstCurrCamPos.y + 150, gdata::vConstCurrCamPos.z), false); } - GData::DXDevice->SetTexture(0, SML_DSGetRT(DS_RT_SCENELIGHT2)); + gdata::pDXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_SCENELIGHT2)); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::ScreenOut); + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idScreenOut); SGCore_ScreenQuadDraw(); @@ -1036,203 +1029,203 @@ void SXRenderFunc::RenderSky(DWORD timeDelta) mem_release(ColorSurf); - GData::DXDevice->SetRenderTarget(0, BackBuf); + gdata::pDXDevice->SetRenderTarget(0, BackBuf); mem_release(BackBuf); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); } -void SXRenderFunc::ComLighting(DWORD timeDelta) +void rfunc::ComLighting(DWORD timeDelta) { static int *r_win_width = (int*)GET_PCVAR_INT("r_win_width"); static int *r_win_height = (int*)GET_PCVAR_INT("r_win_height"); SGCore_ShaderUnBind(); - LPDIRECT3DSURFACE9 AmbientSurf, SpecDiffSurf, BackBuf; - SML_DSGetRT(DS_RT_AMBIENTDIFF)->GetSurfaceLevel(0, &AmbientSurf); - SML_DSGetRT(DS_RT_SPECULAR)->GetSurfaceLevel(0, &SpecDiffSurf); + LPDIRECT3DSURFACE9 pAmbientSurf, pSpecDiffSurf, pBackBuf; + SGCore_GbufferGetRT(DS_RT_AMBIENTDIFF)->GetSurfaceLevel(0, &pAmbientSurf); + SGCore_GbufferGetRT(DS_RT_SPECULAR)->GetSurfaceLevel(0, &pSpecDiffSurf); - GData::DXDevice->GetRenderTarget(0, &BackBuf); + gdata::pDXDevice->GetRenderTarget(0, &pBackBuf); - GData::DXDevice->SetRenderTarget(0, AmbientSurf); - GData::DXDevice->SetRenderTarget(1, SpecDiffSurf); + gdata::pDXDevice->SetRenderTarget(0, pAmbientSurf); + gdata::pDXDevice->SetRenderTarget(1, pSpecDiffSurf); //очищаем рт и стенсил - GData::DXDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_STENCIL, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); + gdata::pDXDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_STENCIL, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); //устанавка аддитивного смешивания //когда к уже записанному будет прибавляться то что хотим записать - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); - GData::DXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE); - GData::DXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE); - GData::DXDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE); + gdata::pDXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE); + gdata::pDXDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD); - GData::DXDevice->SetTransform(D3DTS_WORLD, &((D3DXMATRIX)SMMatrixIdentity())); - GData::DXDevice->SetTransform(D3DTS_VIEW, &((D3DXMATRIX)GData::MCamView)); - GData::DXDevice->SetTransform(D3DTS_PROJECTION, &((D3DXMATRIX)GData::MLightProj)); + gdata::pDXDevice->SetTransform(D3DTS_WORLD, &((D3DXMATRIX)SMMatrixIdentity())); + gdata::pDXDevice->SetTransform(D3DTS_VIEW, &((D3DXMATRIX)gdata::mCamView)); + gdata::pDXDevice->SetTransform(D3DTS_PROJECTION, &((D3DXMATRIX)gdata::mLightProj)); //проходимся циклом по всем источникам света - for (int i = 0; iSetRenderState(D3DRS_COLORWRITEENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, FALSE); //установка стенсил теста, причем и двухстороннего тоже - GData::DXDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE); - GData::DXDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILENABLE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, TRUE); //вклчить тест глубины, но запись выключить, установить стандартную функцию проверки глубины - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL); //стенсил тест проходит всегда удачно, при провале теста глубины инкрементируем значение в стенсиле - GData::DXDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS); - GData::DXDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_INCR); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_INCR); //при удачно проходе, игнорируем - GData::DXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); //стенсил тест для обратной глубины проходит всегда удачно, при провале теста глубины декрементируем значение в стенсиле - GData::DXDevice->SetRenderState(D3DRS_CCW_STENCILFUNC, D3DCMP_ALWAYS); - GData::DXDevice->SetRenderState(D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_DECR); + gdata::pDXDevice->SetRenderState(D3DRS_CCW_STENCILFUNC, D3DCMP_ALWAYS); + gdata::pDXDevice->SetRenderState(D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_DECR); //при удачно проходе, игнорируем - GData::DXDevice->SetRenderState(D3DRS_CCW_STENCILPASS, D3DSTENCILOP_KEEP); + gdata::pDXDevice->SetRenderState(D3DRS_CCW_STENCILPASS, D3DSTENCILOP_KEEP); //установка значений для записи - GData::DXDevice->SetRenderState(D3DRS_STENCILREF, 0x0); - GData::DXDevice->SetRenderState(D3DRS_STENCILMASK, 0xFFFFFFFF); - GData::DXDevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xFFFFFFFF); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); //включение двухсторонней отрисовки + gdata::pDXDevice->SetRenderState(D3DRS_STENCILREF, 0x0); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILMASK, 0xFFFFFFFF); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xFFFFFFFF); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); //включение двухсторонней отрисовки - GData::DXDevice->SetTransform(D3DTS_WORLD, &((D3DXMATRIX)SMMatrixIdentity())); - GData::DXDevice->SetTransform(D3DTS_VIEW, &((D3DXMATRIX)GData::MCamView)); - GData::DXDevice->SetTransform(D3DTS_PROJECTION, &((D3DXMATRIX)GData::MLightProj)); + gdata::pDXDevice->SetTransform(D3DTS_WORLD, &((D3DXMATRIX)SMMatrixIdentity())); + gdata::pDXDevice->SetTransform(D3DTS_VIEW, &((D3DXMATRIX)gdata::mCamView)); + gdata::pDXDevice->SetTransform(D3DTS_PROJECTION, &((D3DXMATRIX)gdata::mLightProj)); //отрисовка ограничивающего объема - SML_LigthsRender(i, 0); + SLight_Render(i, 0); // - GData::DXDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_EQUAL); - GData::DXDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_ZERO); - GData::DXDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_ZERO); - GData::DXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_EQUAL); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_ZERO); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_ZERO); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); - GData::DXDevice->SetRenderState(D3DRS_STENCILREF, 255); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILREF, 255); //включаем вывод цвета - GData::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); } else { //иначе это глобальный источник, отключаем стенсил тест - GData::DXDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE); } //отключаем тест глубины ибо будем теперь пост процессом обрабатывать полученные данные - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); //если свет отбрасывает тени - if (SML_LigthsGetShadowed(i)) + if (SLight_GetShadowed(i)) { //генерация теней для текущего света //{{ //так как нам нужно провести очистку рт то убираем оба рт - GData::DXDevice->SetRenderTarget(0, 0); - GData::DXDevice->SetRenderTarget(1, 0); + gdata::pDXDevice->SetRenderTarget(0, 0); + gdata::pDXDevice->SetRenderTarget(1, 0); //отключаем смешивание, нам не нужен хлам в рт - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED); - SML_LigthsShadowNull(); //очищаем рт генерации теней - SML_LigthsShadowGen(i); //генерируем тень для света + SLight_ShadowNull(); //очищаем рт генерации теней + SLight_ShadowGen(i); //генерируем тень для света static const int * r_shadow_soft = GET_PCVAR_INT("r_shadow_soft"); if (r_shadow_soft) { if ((*r_shadow_soft) == 1) - SML_LigthsShadowSoft(false, 2); + SLight_ShadowSoft(false, 2); else if ((*r_shadow_soft) == 2) { - SML_LigthsShadowSoft(false, 2); - SML_LigthsShadowSoft(false, 2); + SLight_ShadowSoft(false, 2); + SLight_ShadowSoft(false, 2); } } - GData::DXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA); //}} - + //включаем смешивание для освещения - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); //опять назначаем второй рт - GData::DXDevice->SetRenderTarget(0, AmbientSurf); - GData::DXDevice->SetRenderTarget(1, SpecDiffSurf); + gdata::pDXDevice->SetRenderTarget(0, pAmbientSurf); + gdata::pDXDevice->SetRenderTarget(1, pSpecDiffSurf); //устанавливаем текстуру с тенями и переназначаем шейдер, теперь уже с тенями - GData::DXDevice->SetTexture(4, SML_LigthsGetShadow()); - idshader = GData::IDsShaders::PS::ComLightingShadow; + gdata::pDXDevice->SetTexture(4, SLight_GetShadow()); + idshader = gdata::shaders_id::ps::idComLightingShadow; - if (GetAsyncKeyState('Q')) - D3DXSaveTextureToFile((String("C:/1/SML_LigthsGetShadow") + String(i) + ".jpg").c_str(), D3DXIFF_JPG, SML_LigthsGetShadow(), NULL); + //if (GetAsyncKeyState('Q')) + //D3DXSaveTextureToFile((String("C:/1/SLight_GetShadow") + String(i) + ".jpg").c_str(), D3DXIFF_JPG, SLight_GetShadow(), NULL); - /*if (i == SML_LigthsGetGlobal()) - GData::DXDevice->SetTexture(4, SGCore_LoadTexGetTex(SGCore_LoadTexGetID("g_shadow")));*/ + /*if (i == SLight_GetGlobal()) + gdata::pDXDevice->SetTexture(4, SGCore_LoadTexGetTex(SGCore_LoadTexGetID("g_shadow")));*/ } SGCore_ShaderUnBind(); //теперь когда будем считать освещение надо сбросить значения в стенсил буфере, чтобы каждый кадр не чистить //если стенсил тест прошел успешно, устанавливаем значнеие в нуль - if (SML_LigthsGetType(i) != LTYPE_LIGHT_GLOBAL) - GData::DXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_ZERO); + if (SLight_GetType(i) != LTYPE_LIGHT_GLOBAL) + gdata::pDXDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_ZERO); float determ = 0; - float4x4 ViewInv = SMMatrixInverse(&determ, GData::MCamView); + float4x4 ViewInv = SMMatrixInverse(&determ, gdata::mCamView); ViewInv = SMMatrixTranspose(ViewInv); - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ResPos, "g_mViewInv", &ViewInv); - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ResPos, "g_vNearFar", &GData::NearFar); - SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ResPos, "g_vParamProj", &float3_t(*r_win_width, *r_win_height, GData::ProjFov)); + SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idResPos, "g_mViewInv", &ViewInv); + SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idResPos, "g_vNearFar", &gdata::vNearFar); + SGCore_ShaderSetVRF(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idResPos, "g_vParamProj", &float3_t(*r_win_width, *r_win_height, gdata::fProjFov)); float3 tmpPosition; float2 tmpPowerDist; float3 tmpColor; - SML_LigthsGetColor(i, &tmpColor); - SML_LigthsGetPos(i, &tmpPosition, true); - tmpPowerDist.x = SML_LigthsGetPower(i); - tmpPowerDist.y = SML_LigthsGetDist(i); - - if (SML_LigthsGetType(i) != LTYPE_LIGHT_GLOBAL) + SLight_GetColor(i, &tmpColor); + SLight_GetPos(i, &tmpPosition, true); + tmpPowerDist.x = SLight_GetPower(i); + tmpPowerDist.y = SLight_GetDist(i); + + if (SLight_GetType(i) != LTYPE_LIGHT_GLOBAL) { tmpColor.w = 0.f; ID gl_id = -1; - if ((gl_id = SML_LigthsGetGlobal()) >= 0) + if ((gl_id = SLight_GetGlobal()) >= 0) { float gl_power = 0.f; - if (SML_LigthsGetEnable(gl_id)) - gl_power = SML_LigthsGetPower(gl_id); + if (SLight_GetEnable(gl_id)) + gl_power = SLight_GetPower(gl_id); float f_dep_coef = clampf(1.f - gl_power, 0.25f, 1.f); tmpPowerDist.x *= f_dep_coef; @@ -1242,23 +1235,23 @@ void SXRenderFunc::ComLighting(DWORD timeDelta) else tmpColor.w = 1.f; - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, idshader, "g_vViewPos", &GData::ConstCurrCamPos); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, idshader, "g_vViewPos", &gdata::vConstCurrCamPos); SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, idshader, "g_vLightPos", &(tmpPosition)); SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, idshader, "g_vLightPowerDist", &(tmpPowerDist)); SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, idshader, "g_vLightColor", &tmpColor); - //SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, idshader, "NearFar", &GData::NearFar); + //SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, idshader, "vNearFar", &gdata::vNearFar); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ResPos); + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idResPos); SGCore_ShaderBind(SHADER_TYPE_PIXEL, idshader); SetSamplerFilter(0, 5, D3DTEXF_NONE); SetSamplerAddress(0, 5, D3DTADDRESS_CLAMP); - - GData::DXDevice->SetTexture(0, SML_DSGetRT(DS_RT_COLOR)); - GData::DXDevice->SetTexture(1, SML_DSGetRT(DS_RT_NORMAL)); - GData::DXDevice->SetTexture(2, SML_DSGetRT(DS_RT_PARAM)); - GData::DXDevice->SetTexture(3, SML_DSGetRT(DS_RT_DEPTH)); - GData::DXDevice->SetTexture(5, SML_DSGetRT(DS_RT_ADAPTEDLUM)); + + gdata::pDXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_COLOR)); + gdata::pDXDevice->SetTexture(1, SGCore_GbufferGetRT(DS_RT_NORMAL)); + gdata::pDXDevice->SetTexture(2, SGCore_GbufferGetRT(DS_RT_PARAM)); + gdata::pDXDevice->SetTexture(3, SGCore_GbufferGetRT(DS_RT_DEPTH)); + gdata::pDXDevice->SetTexture(5, SGCore_GbufferGetRT(DS_RT_ADAPTEDLUM)); SGCore_ScreenQuadDraw(); @@ -1266,176 +1259,167 @@ void SXRenderFunc::ComLighting(DWORD timeDelta) } } - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - GData::DXDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + gdata::pDXDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_TWOSIDEDSTENCILMODE, FALSE); - GData::DXDevice->SetRenderTarget(0, BackBuf); - GData::DXDevice->SetRenderTarget(1, 0); + gdata::pDXDevice->SetRenderTarget(0, pBackBuf); + gdata::pDXDevice->SetRenderTarget(1, 0); - mem_release(BackBuf); + mem_release(pBackBuf); - mem_release(AmbientSurf); - mem_release(SpecDiffSurf); + mem_release(pAmbientSurf); + mem_release(pSpecDiffSurf); //------------------------------- - - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - + + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + //теперь необходимо все смешать чтобы получить итоговую освещенную картинку //{{ SetSamplerFilter(0, 5, D3DTEXF_NONE); SetSamplerAddress(0, 5, D3DTADDRESS_CLAMP); - LPDIRECT3DSURFACE9 ComLightSurf; + LPDIRECT3DSURFACE9 pComLightSurf; - SML_DSGetRT(DS_RT_SCENELIGHT)->GetSurfaceLevel(0, &ComLightSurf); + SGCore_GbufferGetRT(DS_RT_SCENELIGHT)->GetSurfaceLevel(0, &pComLightSurf); - GData::DXDevice->GetRenderTarget(0, &BackBuf); - GData::DXDevice->SetRenderTarget(0, ComLightSurf); + gdata::pDXDevice->GetRenderTarget(0, &pBackBuf); + gdata::pDXDevice->SetRenderTarget(0, pComLightSurf); //очищаем рт (в старой версии было многопроходное смешивание) - GData::DXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0,0,0,0), 1.0f, 0); - - GData::DXDevice->SetTexture(0, SML_DSGetRT(DS_RT_COLOR)); - GData::DXDevice->SetTexture(1, SML_DSGetRT(DS_RT_AMBIENTDIFF)); - GData::DXDevice->SetTexture(2, SML_DSGetRT(DS_RT_SPECULAR)); - GData::DXDevice->SetTexture(3, SML_DSGetRT(DS_RT_NORMAL)); - GData::DXDevice->SetTexture(4, SML_DSGetRT(DS_RT_ADAPTEDLUM)); - GData::DXDevice->SetTexture(5, SML_DSGetRT(DS_RT_PARAM)); - - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::BlendAmbientSpecDiffColor); - + gdata::pDXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); + + gdata::pDXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_COLOR)); + gdata::pDXDevice->SetTexture(1, SGCore_GbufferGetRT(DS_RT_AMBIENTDIFF)); + gdata::pDXDevice->SetTexture(2, SGCore_GbufferGetRT(DS_RT_SPECULAR)); + gdata::pDXDevice->SetTexture(3, SGCore_GbufferGetRT(DS_RT_NORMAL)); + gdata::pDXDevice->SetTexture(4, SGCore_GbufferGetRT(DS_RT_ADAPTEDLUM)); + gdata::pDXDevice->SetTexture(5, SGCore_GbufferGetRT(DS_RT_PARAM)); + + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idBlendAmbientSpecDiffColor); + SGCore_ScreenQuadDraw(); - mem_release(ComLightSurf); + mem_release(pComLightSurf); //}} SGCore_ShaderUnBind(); - GData::DXDevice->SetRenderTarget(0, BackBuf); - mem_release(BackBuf); + gdata::pDXDevice->SetRenderTarget(0, pBackBuf); + mem_release(pBackBuf); } -void SXRenderFunc::UnionLayers() +void rfunc::UnionLayers() { static const int *r_win_width = GET_PCVAR_INT("r_win_width"); static const int *r_win_height = GET_PCVAR_INT("r_win_height"); - LPDIRECT3DSURFACE9 BackBuf, ComLightSurf; - GData::DXDevice->GetRenderTarget(0, &BackBuf); + LPDIRECT3DSURFACE9 pBackBuf, pComLightSurf; + gdata::pDXDevice->GetRenderTarget(0, &pBackBuf); - static int CurrCountTransparencySurf; + static int iCurrCountTransparencySurf; #if defined(SXMATERIAL_EDITOR) - CurrCountTransparencySurf = 3; + iCurrCountTransparencySurf = 3; #else - CurrCountTransparencySurf = SML_MtlGetCurrCountSurf(); + iCurrCountTransparencySurf = SMtrl_MtlGetCurrCountSurf(); #endif - if (CurrCountTransparencySurf >= RENDER_LAYER_TRANSPARENT) + if (iCurrCountTransparencySurf >= RENDER_LAYER_TRANSPARENT) { - LPDIRECT3DSURFACE9 ColorSurf, Color2Surf, DepthSurf; - SML_DSGetRT(DS_RT_SCENELIGHT2)->GetSurfaceLevel(0, &ColorSurf); - GData::DXDevice->SetRenderTarget(0, ColorSurf); - SML_DSGetRT(DS_RT_DEPTH0)->GetSurfaceLevel(0, &DepthSurf); - GData::DXDevice->SetRenderTarget(1, DepthSurf); - SML_DSGetRT(DS_RT_DEPTH1)->GetSurfaceLevel(0, &Color2Surf); - GData::DXDevice->SetRenderTarget(2, Color2Surf); - GData::DXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); - GData::DXDevice->SetTexture(0, SML_DSGetRT(DS_RT_COLOR)); - GData::DXDevice->SetTexture(1, SML_DSGetRT(DS_RT_SCENELIGHT)); - GData::DXDevice->SetTexture(2, SML_DSGetRT(DS_RT_DEPTH)); - GData::DXDevice->SetTexture(3, SML_DSGetRT(DS_RT_NORMAL)); - GData::DXDevice->SetTexture(4, SML_DSGetRT(DS_RT_PARAM)); - - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::UnionAlpha); - SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::UnionAlpha, "g_vWinSize", &float4_t(*r_win_width, *r_win_height, 1.f / float(*r_win_width), 1.f / float(*r_win_height))); + LPDIRECT3DSURFACE9 pColorSurf, pColor2Surf, pDepthSurf; + SGCore_GbufferGetRT(DS_RT_SCENELIGHT2)->GetSurfaceLevel(0, &pColorSurf); + gdata::pDXDevice->SetRenderTarget(0, pColorSurf); + SGCore_GbufferGetRT(DS_RT_DEPTH0)->GetSurfaceLevel(0, &pDepthSurf); + gdata::pDXDevice->SetRenderTarget(1, pDepthSurf); + SGCore_GbufferGetRT(DS_RT_DEPTH1)->GetSurfaceLevel(0, &pColor2Surf); + gdata::pDXDevice->SetRenderTarget(2, pColor2Surf); + gdata::pDXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); + gdata::pDXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_COLOR)); + gdata::pDXDevice->SetTexture(1, SGCore_GbufferGetRT(DS_RT_SCENELIGHT)); + gdata::pDXDevice->SetTexture(2, SGCore_GbufferGetRT(DS_RT_DEPTH)); + gdata::pDXDevice->SetTexture(3, SGCore_GbufferGetRT(DS_RT_NORMAL)); + gdata::pDXDevice->SetTexture(4, SGCore_GbufferGetRT(DS_RT_PARAM)); + + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idUnionAlpha); + SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idUnionAlpha, "g_vWinSize", &float4_t(*r_win_width, *r_win_height, 1.f / float(*r_win_width), 1.f / float(*r_win_height))); SGCore_ScreenQuadDraw(); - GData::DXDevice->SetRenderTarget(1, 0); - GData::DXDevice->SetRenderTarget(2, 0); - mem_release(ColorSurf); - mem_release(DepthSurf); - mem_release(Color2Surf); + gdata::pDXDevice->SetRenderTarget(1, 0); + gdata::pDXDevice->SetRenderTarget(2, 0); + mem_release(pColorSurf); + mem_release(pDepthSurf); + mem_release(pColor2Surf); } else { //копируем значения только для ds_rt_depth1, а ds_rt_depth0 уже заполнен - LPDIRECT3DSURFACE9 DepthSurf1; + LPDIRECT3DSURFACE9 pDepthSurf1; - SML_DSGetRT(DS_RT_DEPTH1)->GetSurfaceLevel(0, &DepthSurf1); - GData::DXDevice->SetRenderTarget(0, DepthSurf1); + SGCore_GbufferGetRT(DS_RT_DEPTH1)->GetSurfaceLevel(0, &pDepthSurf1); + gdata::pDXDevice->SetRenderTarget(0, pDepthSurf1); - GData::DXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); + gdata::pDXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); - GData::DXDevice->SetTexture(0, SML_DSGetRT(DS_RT_DEPTH)); + gdata::pDXDevice->SetTexture(0, SGCore_GbufferGetRT(DS_RT_DEPTH)); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::ScreenOut); + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idScreenOut); SGCore_ScreenQuadDraw(); - GData::DXDevice->SetRenderTarget(0, 0); - mem_release(DepthSurf1); + gdata::pDXDevice->SetRenderTarget(0, 0); + mem_release(pDepthSurf1); } //копируем итоговую сцену - SML_DSGetRT((CurrCountTransparencySurf >= RENDER_LAYER_TRANSPARENT ? DS_RT_SCENELIGHT : DS_RT_SCENELIGHT2))->GetSurfaceLevel(0, &ComLightSurf); - GData::DXDevice->SetRenderTarget(0, ComLightSurf); - GData::DXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); - GData::DXDevice->SetTexture(0, SML_DSGetRT((CurrCountTransparencySurf >= RENDER_LAYER_TRANSPARENT ? DS_RT_SCENELIGHT2 : DS_RT_SCENELIGHT))); + SGCore_GbufferGetRT((iCurrCountTransparencySurf >= RENDER_LAYER_TRANSPARENT ? DS_RT_SCENELIGHT : DS_RT_SCENELIGHT2))->GetSurfaceLevel(0, &pComLightSurf); + gdata::pDXDevice->SetRenderTarget(0, pComLightSurf); + gdata::pDXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0, 0); + gdata::pDXDevice->SetTexture(0, SGCore_GbufferGetRT((iCurrCountTransparencySurf >= RENDER_LAYER_TRANSPARENT ? DS_RT_SCENELIGHT2 : DS_RT_SCENELIGHT))); - SGCore_ShaderBind(SHADER_TYPE_VERTEX, GData::IDsShaders::VS::ScreenOut); - SGCore_ShaderBind(SHADER_TYPE_PIXEL, GData::IDsShaders::PS::ScreenOut); + SGCore_ShaderBind(SHADER_TYPE_VERTEX, gdata::shaders_id::vs::idScreenOut); + SGCore_ShaderBind(SHADER_TYPE_PIXEL, gdata::shaders_id::ps::idScreenOut); SGCore_ScreenQuadDraw(); - mem_release(ComLightSurf); + mem_release(pComLightSurf); SGCore_ShaderUnBind(); - GData::DXDevice->SetRenderTarget(0, BackBuf); - mem_release(BackBuf); -} - -void SXRenderFunc::ComToneMapping(DWORD timeDelta) -{ - //обработка tone mapping - static const float * r_hdr_adapted_coef = GET_PCVAR_FLOAT("r_hdr_adapted_coef"); - SML_LigthsToneMappingCom(timeDelta, (r_hdr_adapted_coef ? (*r_hdr_adapted_coef) : 0.03f)); + gdata::pDXDevice->SetRenderTarget(0, pBackBuf); + mem_release(pBackBuf); } - - -void SXRenderFunc::RenderParticles(DWORD timeDelta) +void rfunc::RenderParticles(DWORD timeDelta) { - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE); - GData::DXDevice->SetRenderState(D3DRS_ALPHAREF, RENDER_PARTICLES_ALPHATEST_VALUE); - GData::DXDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHAREF, RENDER_PARTICLES_ALPHATEST_VALUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); SetSamplerFilter(0, 3, D3DTEXF_LINEAR); SetSamplerAddress(0, 3, D3DTADDRESS_WRAP); SPE_EffectRenderAll(timeDelta); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); } -void SXRenderFunc::RenderPostProcess(DWORD timeDelta) +void rfunc::RenderMainPostProcess(DWORD timeDelta) { static const int *r_win_width = GET_PCVAR_INT("r_win_width"); static const int *r_win_height = GET_PCVAR_INT("r_win_height"); @@ -1445,79 +1429,98 @@ void SXRenderFunc::RenderPostProcess(DWORD timeDelta) SPP_Update(); SPP_RTNull(); + //********************************************************************** + static const int * pp_ssao = GET_PCVAR_INT("pp_ssao"); if (pp_ssao && (*pp_ssao) > 0) - SPP_RenderSSAO(&float4_t(0.3f, 0.1f, 0.8f, 0.3f / GData::NearFar.y), (*pp_ssao)); + SPP_RenderSSAO(&float4_t(0.3f, 0.1f, 0.8f, 0.3f / gdata::vNearFar.y), (*pp_ssao)); + + //********************************************************************** //создаем статический вектор цвета тумана, затем получаем квар который int типа который будет содеражть указатель на этот вектор, и в него записываем указатель на вектор цвета тумана //static float3_t fog_color(0.5, 0.5, 0.5); static UINT_PTR *pp_fog_color = GET_PCVAR_POINTER("pp_fog_color"); - static float3_t *fog_color; + static float3_t *fog_color; fog_color = (float3_t*)(*pp_fog_color); + //********************************************************************** + static const float * pp_fog_density = GET_PCVAR_FLOAT("pp_fog_density"); - if (pp_fog_density && *pp_fog_density > 0.f ) + if (pp_fog_density && *pp_fog_density > 0.f) SPP_RenderFogLinear(fog_color, *pp_fog_density); - + + //********************************************************************** static const bool * pp_bloom = GET_PCVAR_BOOL("pp_bloom"); if (pp_bloom && (*pp_bloom)) SPP_RenderBloom(&float3_t(1, 0.7, 1.0)); + //********************************************************************** + float3 vGLpos; + float3 vGLcolor; - float3 tmpPosition; - float3 tmpColor; - - ID GlobalLight = SML_LigthsGetGlobal(); - if (GlobalLight > -1) + ID idGlobalLight = SLight_GetGlobal(); + if (idGlobalLight > -1) { - SML_LigthsGetColor(GlobalLight, &tmpColor); - SML_LigthsGetPos(GlobalLight, &tmpPosition, true); + SLight_GetColor(idGlobalLight, &vGLcolor); + SLight_GetPos(idGlobalLight, &vGLpos, true); - SPP_UpdateSun((SML_LigthsGetEnable(GlobalLight) ? &tmpPosition : 0)); + SPP_UpdateSun((SLight_GetEnable(idGlobalLight) ? &vGLpos : 0)); - if (!SML_LigthsGetCastGlobalShadow()) - SPP_RenderSun(&float4_t(tmpColor.x, tmpColor.y, tmpColor.z, SML_LigthsGetPower(GlobalLight))); + if (!SLight_GetCastGlobalShadow()) + SPP_RenderSun(&float4_t(vGLcolor.x, vGLcolor.y, vGLcolor.z, SLight_GetPower(idGlobalLight))); } else SPP_UpdateSun(0); + //********************************************************************** + static const bool * pp_lensflare = GET_PCVAR_BOOL("pp_lensflare"); static const bool * pp_lensflare_usebloom = GET_PCVAR_BOOL("pp_lensflare_usebloom"); - if (pp_lensflare && (*pp_lensflare) && GlobalLight >= 0) - SPP_RenderLensFlare(&float3_t(0.25f, 0.3f, 0.2f), &float4_t(tmpColor.x, tmpColor.y, tmpColor.z, (SML_LigthsGetCastGlobalShadow() ? 0 : SML_LigthsGetPower(GlobalLight))), (pp_lensflare_usebloom ? (*pp_lensflare_usebloom) : false)); + if (pp_lensflare && (*pp_lensflare) && idGlobalLight >= 0) + SPP_RenderLensFlare(&float3_t(0.25f, 0.3f, 0.2f), &float4_t(vGLcolor.x, vGLcolor.y, vGLcolor.z, (SLight_GetCastGlobalShadow() ? 0 : SLight_GetPower(idGlobalLight))), (pp_lensflare_usebloom ? (*pp_lensflare_usebloom) : false)); + //********************************************************************** SPP_RenderDOF(&float4_t(0, 100, 0, 20), 0); - + //********************************************************************** static const bool * pp_nfaa = GET_PCVAR_BOOL("pp_nfaa"); if (pp_nfaa && (*pp_nfaa)) SPP_RenderNFAA(&float3_t(1, 1, 0)); + //********************************************************************** + static const bool * pp_dlaa = GET_PCVAR_BOOL("pp_dlaa"); if (pp_dlaa && (*pp_dlaa)) SPP_RenderDLAA(); + //********************************************************************** + static const bool * pp_motionblur = GET_PCVAR_BOOL("pp_motionblur"); static const float * pp_motionblur_coef = GET_PCVAR_FLOAT("pp_motionblur_coef"); if (pp_motionblur && (*pp_motionblur)) SPP_RenderMotionBlur((pp_motionblur_coef ? (*pp_motionblur_coef) : 0.1), timeDelta); +} - +void rfunc::RenderFinalPostProcess(DWORD timeDelta) +{ static const float * pp_whiteblack_coef = GET_PCVAR_FLOAT("pp_whiteblack_coef"); if (pp_whiteblack_coef && (*pp_whiteblack_coef) > 0.f) SPP_RenderWhiteBlack(*pp_whiteblack_coef); + //********************************************************************** static const float * pp_sepia_coef = GET_PCVAR_FLOAT("pp_sepia_coef"); if (pp_sepia_coef && (*pp_sepia_coef) > 0.f) SPP_RenderSepia((*pp_sepia_coef)); + //********************************************************************** + static const float * pp_contrast = GET_PCVAR_FLOAT("pp_contrast"); static const float * pp_gamma = GET_PCVAR_FLOAT("pp_gamma"); static const float * pp_bright = GET_PCVAR_FLOAT("pp_bright"); @@ -1526,16 +1529,16 @@ void SXRenderFunc::RenderPostProcess(DWORD timeDelta) SPP_RenderCBG(&float3_t((*pp_contrast), (*pp_gamma), (*pp_bright))); } -void SXRenderFunc::ShaderRegisterData() +void rfunc::ShaderRegisterData() { - static float4_t tmpnull[256]; - memset(tmpnull, 0, sizeof(float4_t)* 256); - GData::DXDevice->SetVertexShaderConstantF(0, (float*)&tmpnull, 256); - GData::DXDevice->SetPixelShaderConstantF(0, (float*)&tmpnull, 256); + static float4_t aNull[256]; + memset(aNull, 0, sizeof(float4_t)* 256); + gdata::pDXDevice->SetVertexShaderConstantF(0, (float*)&aNull, 256); + gdata::pDXDevice->SetPixelShaderConstantF(0, (float*)&aNull, 256); } -void SXRenderFunc::UpdateReflectionScene(DWORD timeDelta) +void rfunc::UpdateReflectionScene(DWORD timeDelta) { static const int *r_reflection_render = GET_PCVAR_INT("r_reflection_render"); @@ -1546,256 +1549,256 @@ void SXRenderFunc::UpdateReflectionScene(DWORD timeDelta) { for (int k = 0; k < SGeom_ModelsMGetCountGroups(i); ++k) { - ID idmat = SGeom_ModelsMGetGroupIDMat(i, k); - MTLTYPE_REFLECT typeref = SML_MtlGetTypeReflection(SGeom_ModelsMGetGroupIDMat(i, k)); - D3DXPLANE plane; - float3_t center; - if (typeref == MTLTYPE_REFLECT_PLANE) + ID idMat = SGeom_ModelsMGetGroupIDMat(i, k); + MTLTYPE_REFLECT typeReflection = SMtrl_MtlGetTypeReflection(SGeom_ModelsMGetGroupIDMat(i, k)); + D3DXPLANE oPlane; + float3_t vCenter; + + if (typeReflection == MTLTYPE_REFLECT_PLANE) { - - if (!SML_MtlRefIsAllowedRender(idmat)) + if (!SMtrl_RefIsAllowedRender(idMat)) { - SML_MtlRefUpdateCountUpdate(idmat, &((float3_t)GData::ConstCurrCamPos)); + SMtrl_RefUpdateCountUpdate(idMat, &((float3_t)gdata::vConstCurrCamPos)); continue; } - SGeom_ModelsMGetGroupPlane(i, k, &plane); - SGeom_ModelsMGetGroupCenter(i, k, ¢er); - SML_MtlRefPreRenderPlane(idmat, &plane); + SGeom_ModelsMGetGroupPlane(i, k, &oPlane); + SGeom_ModelsMGetGroupCenter(i, k, &vCenter); + SMtrl_RefPreRenderPlane(idMat, &oPlane); SetSamplerFilter(0, 16, D3DTEXF_LINEAR); SetSamplerAddress(0, 16, D3DTADDRESS_WRAP); Core_RBoolSet(G_RI_BOOL_CLIPPLANE0, true); - Core_RFloat3Set(G_RI_FLOAT3_CLIPPLANE0_NORMAL, &float3(plane.a, plane.b, plane.c)); - Core_RFloat3Set(G_RI_FLOAT3_CLIPPLANE0_POINT, &float3(center)); + Core_RFloat3Set(G_RI_FLOAT3_CLIPPLANE0_NORMAL, &float3(oPlane.a, oPlane.b, oPlane.c)); + Core_RFloat3Set(G_RI_FLOAT3_CLIPPLANE0_POINT, &float3(vCenter)); if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0) >= 0) - SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, 0), false, i, k); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, 0) >= 0) + SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, 0), false, i, k); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0) >= 0) - SGeom_GreenRender(timeDelta, &float3(center), GREEN_TYPE_ALL, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, 0)); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GREEN, 0) >= 0) + SGeom_GreenRender(timeDelta, &float3(vCenter), GREEN_TYPE_ALL, SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GREEN, 0)); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM) { - SXAnim_Render(); + SXAnim_Render(); } SGCore_ShaderUnBind(); if (SGCore_SkyBoxIsCr()) { - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); - GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); - GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); + gdata::pDXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); + gdata::pDXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); - GData::DXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_INVDESTALPHA); - GData::DXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_INVDESTALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); SetSamplerAddress(0, 2, D3DTADDRESS_CLAMP); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MRefPlaneSkyProj); - SGCore_SkyBoxRender(timeDelta, &float3(center)); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &gdata::mRefPlaneSkyProj); + SGCore_SkyBoxRender(timeDelta, &float3(vCenter)); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); } - SML_MtlRefPostRenderPlane(idmat); + SMtrl_RefPostRenderPlane(idMat); } - else if (typeref == MTLTYPE_REFLECT_CUBE_STATIC || typeref == MTLTYPE_REFLECT_CUBE_DYNAMIC) + else if (typeReflection == MTLTYPE_REFLECT_CUBE_STATIC || typeReflection == MTLTYPE_REFLECT_CUBE_DYNAMIC) { - SGeom_ModelsMGetGroupCenter(i, k, ¢er); + SGeom_ModelsMGetGroupCenter(i, k, &vCenter); float3_t min, max; SGeom_ModelsMGetGroupMin(i, k, &min); SGeom_ModelsMGetGroupMax(i, k, &max); - SML_MtlRefSetMinMax(idmat, &min, &max); + SMtrl_RefSetMinMax(idMat, &min, &max); - if (!SML_MtlRefIsAllowedRender(idmat)) + if (!SMtrl_RefIsAllowedRender(idMat)) { - SML_MtlRefUpdateCountUpdate(idmat, &((float3_t)GData::ConstCurrCamPos)); + SMtrl_RefUpdateCountUpdate(idMat, &((float3_t)gdata::vConstCurrCamPos)); continue; } - SML_MtlRefCubeBeginRender(idmat, ¢er); + SMtrl_RefCubeBeginRender(idMat, &vCenter); for (int j = 0; j < 6; j++) { Core_RMatrixSet(G_RI_MATRIX_WORLD, &SMMatrixIdentity()); - SML_MtlRefCubePreRender(idmat, j, &(SMMatrixIdentity())); + SMtrl_RefCubePreRender(idMat, j, &(SMMatrixIdentity())); SetSamplerFilter(0, 16, D3DTEXF_LINEAR); SetSamplerAddress(0, 16, D3DTADDRESS_WRAP); if (r_reflection_render && (*r_reflection_render) != 0) { - //если статические кубические отражения - if (SML_MtlGetTypeReflection(idmat) == MTLTYPE_REFLECT_CUBE_STATIC) - { - //тогда считаем в массив камеры + //если статические кубические отражения + if (SMtrl_MtlGetTypeReflection(idMat) == MTLTYPE_REFLECT_CUBE_STATIC) + { + //тогда считаем в массив камеры if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM) { - SGeom_ModelsComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), GData::DefaultGeomIDArr); - SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, GData::DefaultGeomIDArr, false, i, k); + SGeom_ModelsComVisible(SMtrl_RefGetfrustum(idMat, j), &float3(vCenter), gdata::idDefaultGeomArr); + SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, gdata::idDefaultGeomArr, false, i, k); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN) { - SGeom_GreenComVisible(SML_MtlRefGetfrustum(idmat, j), &float3(center), GData::DefaultGreenIDArr); - SGeom_GreenRender(timeDelta, &float3(center), GREEN_TYPE_ALL, GData::DefaultGreenIDArr); - } + SGeom_GreenComVisible(SMtrl_RefGetfrustum(idMat, j), &float3(vCenter), gdata::idDefaultGreenArr); + SGeom_GreenRender(timeDelta, &float3(vCenter), GREEN_TYPE_ALL, gdata::idDefaultGreenArr); + } } - else - { + else + { if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GEOM) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k) >= 0) - SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GEOM, k), false, i, k); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, k) >= 0) + SGeom_ModelsRender(timeDelta, MTLSORT_OPAQUE, SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GEOM, k), false, i, k); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_GREEN) { - if (SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k) >= 0) - SGeom_GreenRender(timeDelta, &GData::ConstCurrCamPos, GREEN_TYPE_ALL, SML_MtlRefGetIDArr(idmat, RENDER_IDARRCOM_GREEN, k)); + if (SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GREEN, k) >= 0) + SGeom_GreenRender(timeDelta, &gdata::vConstCurrCamPos, GREEN_TYPE_ALL, SMtrl_RefGetIDArr(idMat, RENDER_IDARRCOM_GREEN, k)); } if (r_reflection_render && (*r_reflection_render) >= REFLECTION_RENDER_ANIM) { - SXAnim_Render(); - } + SXAnim_Render(); + } } } if (SGCore_SkyBoxIsCr()) { - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); - GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); - GData::DXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); + gdata::pDXDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); + gdata::pDXDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); - GData::DXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_INVDESTALPHA); - GData::DXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_INVDESTALPHA); + gdata::pDXDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); - SetSamplerAddress(0, 2, D3DTADDRESS_CLAMP); + gdata::pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); + SetSamplerAddress(0, 2, D3DTADDRESS_CLAMP); - Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MRefCubeSkyProj); + Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &gdata::mRefCubeSkyProj); - SGCore_SkyBoxRender(timeDelta, &float3(center)); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + SGCore_SkyBoxRender(timeDelta, &float3(vCenter)); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - SML_MtlRefCubePostRender(idmat, j); + SMtrl_RefCubePostRender(idMat, j); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); - } + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + } } - SML_MtlRefCubeEndRender(idmat, &((float3_t)GData::ConstCurrCamPos)); + SMtrl_RefCubeEndRender(idMat, &((float3_t)gdata::vConstCurrCamPos)); } } } } -void SXRenderFunc::UpdateReflectionSimModel(DWORD timeDelta) +void rfunc::UpdateReflectionSimModel(DWORD timeDelta) { - ID idmat = GData::Editors::SimModel->getIdMtl(); - MTLTYPE_REFLECT typeref = SML_MtlGetTypeReflection(idmat); - D3DXPLANE plane; - float3_t center; - GData::Editors::SimModel->getCenter(¢er); + ID idMat = gdata::Editors::pSimModel->getIdMtl(); + MTLTYPE_REFLECT typeReflection = SMtrl_MtlGetTypeReflection(idMat); + D3DXPLANE oPlane; + float3_t vCenter; + gdata::Editors::pSimModel->getCenter(&vCenter); SGCore_ShaderUnBind(); - if (typeref == MTLTYPE_REFLECT_PLANE) + if (typeReflection == MTLTYPE_REFLECT_PLANE) { - GData::Editors::SimModel->getPlane(&plane); - SML_MtlRefPreRenderPlane(idmat, &plane); + gdata::Editors::pSimModel->getPlane(&oPlane); + SMtrl_RefPreRenderPlane(idMat, &oPlane); SetSamplerFilter(0, 16, D3DTEXF_LINEAR); SetSamplerAddress(0, 16, D3DTADDRESS_WRAP); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MRefPlaneSkyProj); - SGCore_SkyBoxRender(timeDelta, &float3(center)); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &gdata::mRefPlaneSkyProj); + SGCore_SkyBoxRender(timeDelta, &float3(vCenter)); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); - SML_MtlRefPostRenderPlane(idmat); + SMtrl_RefPostRenderPlane(idMat); } - else if (typeref == MTLTYPE_REFLECT_CUBE_STATIC || typeref == MTLTYPE_REFLECT_CUBE_DYNAMIC) + else if (typeReflection == MTLTYPE_REFLECT_CUBE_STATIC || typeReflection == MTLTYPE_REFLECT_CUBE_DYNAMIC) { - SML_MtlRefCubeBeginRender(idmat, ¢er); + SMtrl_RefCubeBeginRender(idMat, &vCenter); - for (int j = 0; j<6; j++) + for (int j = 0; j<6; ++j) { Core_RMatrixGet(G_RI_MATRIX_WORLD, &SMMatrixIdentity()); - SML_MtlRefCubePreRender(idmat, j, &(SMMatrixIdentity())); + SMtrl_RefCubePreRender(idMat, j, &(SMMatrixIdentity())); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &GData::MRefCubeSkyProj); - SGCore_SkyBoxRender(timeDelta, &float3(center)); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + Core_RMatrixSet(G_RI_MATRIX_PROJECTION, &gdata::mRefCubeSkyProj); + SGCore_SkyBoxRender(timeDelta, &float3(vCenter)); - GData::DXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); - SML_MtlRefCubePostRender(idmat, j); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + SMtrl_RefCubePostRender(idMat, j); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); } - SML_MtlRefCubeEndRender(idmat, &((float3_t)GData::ConstCurrCamPos)); + SMtrl_RefCubeEndRender(idMat, &((float3_t)gdata::vConstCurrCamPos)); } } -void SXRenderFunc::UpdateReflection(DWORD timeDelta, bool isRenderSimulation) +void rfunc::UpdateReflection(DWORD timeDelta, bool isRenderSimulation) { Core_RIntSet(G_RI_INT_RENDERSTATE, RENDER_STATE_FREE); Core_RMatrixSet(G_RI_MATRIX_WORLD, &SMMatrixIdentity()); - Core_RMatrixSet(G_RI_MATRIX_VIEW, &GData::MCamView); + Core_RMatrixSet(G_RI_MATRIX_VIEW, &gdata::mCamView); - GData::DXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); if (!isRenderSimulation) - SXRenderFunc::UpdateReflectionScene(timeDelta); + rfunc::UpdateReflectionScene(timeDelta); else - SXRenderFunc::UpdateReflectionSimModel(timeDelta); + rfunc::UpdateReflectionSimModel(timeDelta); } //########################################################################## -void SXRenderFunc::RenderEditorMain() +void rfunc::RenderEditorMain() { - if (GData::Editors::ObjGrid && GData::Editors::RenderGrid) + if (gdata::Editors::pGrid && gdata::Editors::canRenderGrid) { - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); - GData::Editors::ObjGrid->render(); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::Editors::pGrid->render(); } - if (GData::Editors::ObjAxesStatic && GData::Editors::RenderAxesStatic) + if (gdata::Editors::pAxesStatic && gdata::Editors::canRenderAxesStatic) { - GData::DXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); - GData::DXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); - GData::Editors::ObjAxesStatic->render(); + gdata::pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE); + gdata::pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_TRUE); + gdata::Editors::pAxesStatic->render(); } } diff --git a/source/render/render_func.h b/source/render/render_func.h index 04bb2bea632e168cd1d4aaaa0523d39d4897969a..9a2b9ed34748cb58394899eed944941536eeb49f 100644 --- a/source/render/render_func.h +++ b/source/render/render_func.h @@ -27,7 +27,7 @@ See the license in LICENSE #include #include -#include +#include #include #include #include @@ -44,17 +44,17 @@ enum REFLECTION_RENDER }; //! пространство имен с орагнизацией рендера -namespace SXRenderFunc +namespace rfunc { //быстрая реализация фильтрации и адресации //{ //индифидуально для регистра - inline void SetSamplerFilter(DWORD id, DWORD value); - inline void SetSamplerAddress(DWORD id, DWORD value); + inline void SetSamplerFilter(DWORD dwId, DWORD dwValue); + inline void SetSamplerAddress(DWORD dwId, DWORD dwValue); //для указанного промежутка групп регистров - inline void SetSamplerFilter(DWORD begin_id, DWORD end_id, DWORD value); - inline void SetSamplerAddress(DWORD begin_id, DWORD end_id, DWORD value); + inline void SetSamplerFilter(DWORD dwIdStart, DWORD dwIdFisnish, DWORD dwValue); + inline void SetSamplerAddress(DWORD dwIdStart, DWORD dwIdFisnish, DWORD dwValue); void SetRenderSceneFilter(); void SetRenderSceneFilterUn(); @@ -103,19 +103,15 @@ namespace SXRenderFunc //! объединение слоев прозрачности void UnionLayers(); - - //! применение тонмаппинга к рт - //void ApplyToneMapping(); - - //! просчет тонмаппинга - void ComToneMapping(DWORD timeDelta); //! отрисовка партиклов (эффектов) void RenderParticles(DWORD timeDelta); - //! отрисовка постпроцесса - void RenderPostProcess(DWORD timeDelta); + //! отрисовка основного постпроцесса + void RenderMainPostProcess(DWORD timeDelta); + + void RenderFinalPostProcess(DWORD timeDelta); void ShaderRegisterData(); @@ -139,29 +135,6 @@ namespace SXRenderFunc void ChangeModeWindow(); void FullScreenChangeSizeAbs(); - - //! время задержек/ожидания выполнения некоторых функций рендера - /*namespace Delay - { - extern int64_t UpdateVisibleForCamera; - extern int64_t UpdateVisibleForLight; - extern int64_t UpdateVisibleForReflection; - - extern int64_t UpdateShadow; - extern int64_t UpdateParticles; - extern int64_t RenderMRT; - extern int64_t ComLighting; - extern int64_t PostProcess; - extern int64_t ComReflection; - extern int64_t GeomSortGroup; - - extern int64_t Present; - - extern int64_t FreeVal; - extern float FreeValF1; - extern float FreeValF2; - extern float FreeValF3; - };*/ }; #endif diff --git a/source/render/simulation_model.cpp b/source/render/simulation_model.cpp index 118dc660067d5702afa0cd73e3b59dc4a6af4794..801d57c82a0f14b8af351c149fbd451acdb6ad51 100644 --- a/source/render/simulation_model.cpp +++ b/source/render/simulation_model.cpp @@ -19,7 +19,7 @@ CSimulationModel::CSimulationModel() D3DDECL_END() }; - GData::DXDevice->CreateVertexDeclaration(layoutstatic, &m_pVertexDeclarationStatic); + gdata::pDXDevice->CreateVertexDeclaration(layoutstatic, &m_pVertexDeclarationStatic); D3DVERTEXELEMENT9 InstanceGreen[] = @@ -33,7 +33,7 @@ CSimulationModel::CSimulationModel() D3DDECL_END() }; - GData::DXDevice->CreateVertexDeclaration(InstanceGreen, &m_pVertexDeclarationGreen); + gdata::pDXDevice->CreateVertexDeclaration(InstanceGreen, &m_pVertexDeclarationGreen); D3DVERTEXELEMENT9 layoutDynamic[] = { @@ -44,9 +44,9 @@ CSimulationModel::CSimulationModel() { 0, 36, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0 }, D3DDECL_END() }; - GData::DXDevice->CreateVertexDeclaration(layoutDynamic, &m_pVertexDeclarationSkin); + gdata::pDXDevice->CreateVertexDeclaration(layoutDynamic, &m_pVertexDeclarationSkin); - GData::DXDevice->CreateVertexBuffer( + gdata::pDXDevice->CreateVertexBuffer( 1 * sizeof(CGreenDataVertex), /*D3DUSAGE_DYNAMIC | */D3DUSAGE_WRITEONLY, 0, @@ -147,7 +147,7 @@ void CSimulationModel::add(const char *szPath) m_aModels.push_back(new CModel(pStaticModel, &Center, &Max, &Min, &Plane)); IDirect3DVertexBuffer9* Anim; - GData::DXDevice->CreateVertexBuffer( + gdata::pDXDevice->CreateVertexBuffer( pStaticModel->m_uiAllVertexCount * sizeof(vertex_animated), D3DUSAGE_WRITEONLY, 0, @@ -223,9 +223,9 @@ void CSimulationModel::render(DWORD timeDelta) void CSimulationModel::renderStatic(DWORD timeDelta) { - GData::DXDevice->SetStreamSource(0, m_aModels[m_iCurrRenderModel]->m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static)); - GData::DXDevice->SetIndices(m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexBuffer); - GData::DXDevice->SetVertexDeclaration(m_pVertexDeclarationStatic); + gdata::pDXDevice->SetStreamSource(0, m_aModels[m_iCurrRenderModel]->m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static)); + gdata::pDXDevice->SetIndices(m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexBuffer); + gdata::pDXDevice->SetVertexDeclaration(m_pVertexDeclarationStatic); SGCore_MtlSet(m_idMtrl, &m_mWorld); SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, m_aModels[m_iCurrRenderModel]->m_pModel->m_pVertexCount[0], 0, m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexCount[0] / 3); @@ -234,14 +234,14 @@ void CSimulationModel::renderStatic(DWORD timeDelta) void CSimulationModel::renderGreen(DWORD timeDelta) { - GData::DXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | 1)); + gdata::pDXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | 1)); - GData::DXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1)); - GData::DXDevice->SetStreamSource(1, m_pTransVertBufGreen, 0, sizeof(CGreenDataVertex)); + gdata::pDXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1)); + gdata::pDXDevice->SetStreamSource(1, m_pTransVertBufGreen, 0, sizeof(CGreenDataVertex)); - GData::DXDevice->SetStreamSource(0, m_aModels[m_iCurrRenderModel]->m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static)); - GData::DXDevice->SetIndices(m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexBuffer); - GData::DXDevice->SetVertexDeclaration(m_pVertexDeclarationGreen); + gdata::pDXDevice->SetStreamSource(0, m_aModels[m_iCurrRenderModel]->m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static)); + gdata::pDXDevice->SetIndices(m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexBuffer); + gdata::pDXDevice->SetVertexDeclaration(m_pVertexDeclarationGreen); long jCountIndex = 0; @@ -251,8 +251,8 @@ void CSimulationModel::renderGreen(DWORD timeDelta) Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + ((m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexCount[0] / 3) * 1)); jCountIndex += m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexCount[0]; - GData::DXDevice->SetStreamSourceFreq(0, 1); - GData::DXDevice->SetStreamSourceFreq(1, 1); + gdata::pDXDevice->SetStreamSourceFreq(0, 1); + gdata::pDXDevice->SetStreamSourceFreq(1, 1); } void CSimulationModel::renderSkin(DWORD timeDelta) @@ -261,12 +261,12 @@ void CSimulationModel::renderSkin(DWORD timeDelta) mbs.position = float4(0, 0, 0, 1); mbs.orient = SMQuaternion(); - GData::DXDevice->SetStreamSource(0, m_aModels[m_iCurrRenderModel]->m_pAnim, 0, sizeof(vertex_animated)); - GData::DXDevice->SetIndices(m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexBuffer); - GData::DXDevice->SetVertexDeclaration(m_pVertexDeclarationSkin); + gdata::pDXDevice->SetStreamSource(0, m_aModels[m_iCurrRenderModel]->m_pAnim, 0, sizeof(vertex_animated)); + gdata::pDXDevice->SetIndices(m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexBuffer); + gdata::pDXDevice->SetVertexDeclaration(m_pVertexDeclarationSkin); SGCore_MtlSet(m_idMtrl, &m_mWorld); - GData::DXDevice->SetVertexShaderConstantF(16, (float*)&mbs, 2); + gdata::pDXDevice->SetVertexShaderConstantF(16, (float*)&mbs, 2); SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, m_aModels[m_iCurrRenderModel]->m_pModel->m_pVertexCount[0], 0, m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexCount[0] / 3); Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_aModels[m_iCurrRenderModel]->m_pModel->m_pIndexCount[0] / 3); } \ No newline at end of file diff --git a/source/render/simulation_model.h b/source/render/simulation_model.h index b7b8d5094993dd78b582b564bb5952e5f51f8213..7c228037a51eba7080ab7a28a9ac30bb27bedd24 100644 --- a/source/render/simulation_model.h +++ b/source/render/simulation_model.h @@ -21,7 +21,7 @@ See the license in LICENSE #define SM_D3D_CONVERSIONS #include #include -#include +#include #include #include diff --git a/source/render/sxrender.cpp b/source/render/sxrender.cpp index 9e4fe66fcc4ba462ad5d6214f539a12b1118f1fc..abfa16fbe3835d4a9dfe0b8bc60ba7857e621f64 100644 --- a/source/render/sxrender.cpp +++ b/source/render/sxrender.cpp @@ -18,7 +18,7 @@ See the license in LICENSE report_func g_fnReportf = DefReport; #endif -#define SR_PRECOND(retval) if(!GData::DXDevice){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxrender is not init", GEN_MSG_LOCATION); return retval;} +#define SR_PRECOND(retval) if(!gdata::pDXDevice){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxrender is not init", GEN_MSG_LOCATION); return retval;} //########################################################################## @@ -47,40 +47,40 @@ SX_LIB_API void SRender_0Create(const char *szName, HWND hWnd3D, HWND hWndParent } } - GData::Handle3D = hWnd3D; - GData::HandleParent3D = hWndParent3D; + gdata::hHandle3D = hWnd3D; + gdata::hHandleParent3D = hWndParent3D; - GData::DXDevice = SGCore_GetDXDevice(); + gdata::pDXDevice = SGCore_GetDXDevice(); - GData::ObjCamera = SGCore_CrCamera(); - GData::ObjCamera->setFOV(GData::ProjFov); + gdata::pCamera = SGCore_CrCamera(); + gdata::pCamera->setFOV(gdata::fProjFov); - GData::InitAllMatrix(); + gdata::InitAllMatrix(); - GData::IDsShaders::InitAllShaders(); + gdata::shaders_id::InitAllShaders(); //********************** - GData::Editors::SimModel = new CSimulationModel(); + gdata::Editors::pSimModel = new CSimulationModel(); - GData::Editors::ObjGrid = new CGrid(); - GData::Editors::ObjGrid->create(100, 100, D3DCOLOR_ARGB(255, 200, 200, 200)); + gdata::Editors::pGrid = new CGrid(); + gdata::Editors::pGrid->create(100, 100, D3DCOLOR_ARGB(255, 200, 200, 200)); - GData::Editors::ObjAxesStatic = new CAxesStatic(); - GData::Editors::ObjAxesStatic->create(1); + gdata::Editors::pAxesStatic = new CAxesStatic(); + gdata::Editors::pAxesStatic->create(1); - GData::Editors::RenderGrid = GData::Editors::RenderAxesStatic = false; + gdata::Editors::canRenderGrid = gdata::Editors::canRenderAxesStatic = false; - /*GData::Editors::RenderBoundBox = GData::Editors::RenderBoundSphere = GData::Editors::RenderBoundCone = false; + /*gdata::Editors::RenderBoundBox = gdata::Editors::RenderBoundSphere = gdata::Editors::RenderBoundCone = false; - D3DXCreateBox(GData::DXDevice, 1, 1, 1, &GData::Editors::FigureBox, 0); - D3DXCreateSphere(GData::DXDevice, 1, 20, 20, &GData::Editors::FigureSphere, 0); + D3DXCreateBox(gdata::pDXDevice, 1, 1, 1, &gdata::Editors::FigureBox, 0); + D3DXCreateSphere(gdata::pDXDevice, 1, 20, 20, &gdata::Editors::FigureSphere, 0); - GData::Editors::vFigureConeParam.x = 1; - GData::Editors::vFigureConeParam.y = 0.1; - GData::Editors::vFigureConeParam.z = 1; + gdata::Editors::vFigureConeParam.x = 1; + gdata::Editors::vFigureConeParam.y = 0.1; + gdata::Editors::vFigureConeParam.z = 1; - SGCore_FCreateCone(GData::Editors::vFigureConeParam.x, GData::Editors::vFigureConeParam.y, GData::Editors::vFigureConeParam.z, &GData::Editors::FigureCone, 20); + SGCore_FCreateCone(gdata::Editors::vFigureConeParam.x, gdata::Editors::vFigureConeParam.y, gdata::Editors::vFigureConeParam.z, &gdata::Editors::FigureCone, 20); */ //*********************** @@ -97,7 +97,7 @@ SX_LIB_API void SRender_0Create(const char *szName, HWND hWnd3D, HWND hWndParent SelectMaterial->UnlockRect(0); //SGCore_LoadTexLoadTextures(); - GData::IDSelectTex = SGCore_LoadTexCreate("select_material__", SelectMaterial); + gdata::idSelectTex = SGCore_LoadTexCreate("select_material__", SelectMaterial); //SGCore_LoadTexLoadTextures(); } @@ -109,106 +109,101 @@ SX_LIB_API void SRender_AKill() { SR_PRECOND(_VOID); - /*mem_delete(GData::Editors::SimModel); + /*mem_delete(gdata::Editors::SimModel); - mem_delete(GData::Editors::ObjGrid); - mem_delete(GData::Editors::ObjAxesStatic); - mem_release(GData::Editors::FigureBox); - mem_release(GData::Editors::FigureSphere); - mem_release(GData::Editors::FigureCone); - mem_delete(GData::Editors::ObjAxesHelper);*/ + mem_delete(gdata::Editors::ObjGrid); + mem_delete(gdata::Editors::ObjAxesStatic); + mem_release(gdata::Editors::FigureBox); + mem_release(gdata::Editors::FigureSphere); + mem_release(gdata::Editors::FigureCone); + mem_delete(gdata::Editors::ObjAxesHelper);*/ - mem_release(GData::ObjCamera); + mem_release(gdata::pCamera); } //########################################################################## SX_LIB_API HWND SRender_GetHandleWin3D() { - return GData::Handle3D; + return gdata::hHandle3D; } SX_LIB_API HWND SRender_GetParentHandleWin3D() { - return GData::HandleParent3D; + return gdata::hHandleParent3D; } SX_LIB_API void SRender_SetHandleWin3D(HWND hWnd) { - GData::Handle3D = hWnd; + gdata::hHandle3D = hWnd; } SX_LIB_API void SRender_SetParentHandleWin3D(HWND hWnd) { - GData::HandleParent3D = hWnd; + gdata::hHandleParent3D = hWnd; } SX_LIB_API void SRender_SetCamera(ICamera *pCamera) { - GData::ObjCamera = pCamera; + gdata::pCamera = pCamera; } SX_LIB_API ICamera* SRender_GetCamera() { - return GData::ObjCamera; + return gdata::pCamera; } SX_LIB_API void SRender_EditorCameraSetMove(bool canMove) { - GData::Editors::MoveCamera = canMove; + gdata::Editors::canMoveCamera = canMove; } SX_LIB_API bool SRender_EditorCameraGetMove() { - return GData::Editors::MoveCamera; + return gdata::Editors::canMoveCamera; } //************************************************************************** -/*SX_LIB_API void SRender_SimModelSetPosition(const float3 *pPos) -{ - -}*/ - SX_LIB_API void SRender_SimModelAdd(const char *szName) { - GData::Editors::SimModel->add(szName); + gdata::Editors::pSimModel->add(szName); } SX_LIB_API ID SRender_SimModelGetIDMtl() { - return GData::Editors::SimModel->getIdMtl(); + return gdata::Editors::pSimModel->getIdMtl(); } SX_LIB_API MTLTYPE_MODEL SRender_SimModelGetType() { - return GData::Editors::SimModel->m_type_model; + return gdata::Editors::pSimModel->m_type_model; } SX_LIB_API void SRender_SimModelSetType(MTLTYPE_MODEL type) { - GData::Editors::SimModel->m_type_model = type; + gdata::Editors::pSimModel->m_type_model = type; } SX_LIB_API void SRender_SimModelSetNumCurrModel(int iCurrNumModel) { - GData::Editors::SimModel->m_iCurrRenderModel = iCurrNumModel; + gdata::Editors::pSimModel->m_iCurrRenderModel = iCurrNumModel; } SX_LIB_API int SRender_SimModelGetNumCurrModel() { - return GData::Editors::SimModel->m_iCurrRenderModel; + return gdata::Editors::pSimModel->m_iCurrRenderModel; } SX_LIB_API void SRender_SimModelSetRotationY(float Rotation) { - GData::Editors::SimModel->m_vRotation.y = Rotation; + gdata::Editors::pSimModel->m_vRotation.y = Rotation; } SX_LIB_API float SRender_SimModelGetRotationY() { - return GData::Editors::SimModel->m_vRotation.y; + return gdata::Editors::pSimModel->m_vRotation.y; } //########################################################################## @@ -227,28 +222,28 @@ SX_LIB_API void SRender_UpdateEditorial(DWORD timeDelta) SX_LIB_API void SRender_EditorSetRenderGrid(bool canRender) { - GData::Editors::RenderGrid = canRender; + gdata::Editors::canRenderGrid = canRender; } SX_LIB_API bool SRender_EditorGetRenderGrid() { - return GData::Editors::RenderGrid; + return gdata::Editors::canRenderGrid; } SX_LIB_API void SRender_EditorSetRenderAxesStatic(bool canRender) { - GData::Editors::RenderAxesStatic = canRender; + gdata::Editors::canRenderAxesStatic = canRender; } SX_LIB_API bool SRender_EditorGetRenderAxesStatic() { - return GData::Editors::RenderAxesStatic; + return gdata::Editors::canRenderAxesStatic; } SX_LIB_API ID SRender_EditorGetSelectTex() { - return GData::IDSelectTex; + return gdata::idSelectTex; } //########################################################################## @@ -256,100 +251,100 @@ SX_LIB_API ID SRender_EditorGetSelectTex() SX_LIB_API void SRender_ComDeviceLost(bool isSetWindowSize) { - SXRenderFunc::ComDeviceLost(isSetWindowSize); + rfunc::ComDeviceLost(isSetWindowSize); } SX_LIB_API void SRender_ComVisibleForLight() { - SXRenderFunc::ComVisibleForLight(); + rfunc::ComVisibleForLight(); } SX_LIB_API void SRender_ComVisibleForCamera() { - SXRenderFunc::ComVisibleForCamera(); + rfunc::ComVisibleForCamera(); } SX_LIB_API void SRender_ComVisibleReflection() { - SXRenderFunc::ComVisibleReflection(); + rfunc::ComVisibleReflection(); } SX_LIB_API void SRender_UpdateView() { - SXRenderFunc::UpdateView(); + rfunc::UpdateView(); } SX_LIB_API int SRender_OutputDebugInfo(DWORD timeDelta, bool needGameTime, const char *szStr) { - return SXRenderFunc::OutputDebugInfo(timeDelta, needGameTime, szStr); + return rfunc::OutputDebugInfo(timeDelta, needGameTime, szStr); } SX_LIB_API void SRender_BuildMRT(DWORD timeDelta, bool isRenderSimulation) { - SXRenderFunc::BuildMRT(timeDelta, isRenderSimulation); + rfunc::BuildMRT(timeDelta, isRenderSimulation); } SX_LIB_API void SRender_UpdateShadow(DWORD timeDelta) { - SXRenderFunc::UpdateShadow(timeDelta); + rfunc::UpdateShadow(timeDelta); } SX_LIB_API void SRender_UpdateReflection(DWORD timeDelta, bool isRenderSimulation) { - SXRenderFunc::UpdateReflection(timeDelta, isRenderSimulation); + rfunc::UpdateReflection(timeDelta, isRenderSimulation); } SX_LIB_API void SRender_UpdateReflectionScene(DWORD timeDelta) { - SXRenderFunc::UpdateReflectionScene(timeDelta); + rfunc::UpdateReflectionScene(timeDelta); } SX_LIB_API void SRender_UpdateReflectionSimModel(DWORD timeDelta) { - SXRenderFunc::UpdateReflectionSimModel(timeDelta); + rfunc::UpdateReflectionSimModel(timeDelta); } SX_LIB_API void SRender_RenderSky(DWORD timeDelta) { - SXRenderFunc::RenderSky(timeDelta); + rfunc::RenderSky(timeDelta); } SX_LIB_API void SRender_ComLighting(DWORD timeDelta) { - SXRenderFunc::ComLighting(timeDelta); + rfunc::ComLighting(timeDelta); } SX_LIB_API void SRender_UnionLayers() { - SXRenderFunc::UnionLayers(); + rfunc::UnionLayers(); } -SX_LIB_API void SRender_ComToneMapping(DWORD timeDelta) + +SX_LIB_API void SRender_RenderParticles(DWORD timeDelta) { - SXRenderFunc::ComToneMapping(timeDelta); + rfunc::RenderParticles(timeDelta); } - -SX_LIB_API void SRender_RenderParticles(DWORD timeDelta) +SX_LIB_API void SRender_RenderMainPostProcess(DWORD timeDelta) { - SXRenderFunc::RenderParticles(timeDelta); + rfunc::RenderMainPostProcess(timeDelta); } -SX_LIB_API void SRender_RenderPostProcess(DWORD timeDelta) +SX_LIB_API void SRender_RenderFinalPostProcess(DWORD timeDelta) { - SXRenderFunc::RenderPostProcess(timeDelta); + rfunc::RenderFinalPostProcess(timeDelta); } SX_LIB_API void SRender_ShaderRegisterData() { - SXRenderFunc::ShaderRegisterData(); + rfunc::ShaderRegisterData(); } SX_LIB_API void SRender_RenderEditorMain() { - SXRenderFunc::RenderEditorMain(); + rfunc::RenderEditorMain(); } //########################################################################## @@ -357,22 +352,22 @@ SX_LIB_API void SRender_RenderEditorMain() SX_LIB_API void SRender_SaveScreenShot() { - SXRenderFunc::SaveScreenShot(); + rfunc::SaveScreenShot(); } SX_LIB_API void SRender_SaveWorkTex() { - SXRenderFunc::SaveWorkTex(); + rfunc::SaveWorkTex(); } SX_LIB_API void SRender_ChangeModeWindow() { //LibReport(REPORT_MSG_LEVEL_NOTICE, "SRender_ChangeModeWindow\n"); - SXRenderFunc::ChangeModeWindow(); + rfunc::ChangeModeWindow(); //LibReport(REPORT_MSG_LEVEL_NOTICE, "SRender_ChangeModeWindow --\n"); } SX_LIB_API void SRender_FullScreenChangeSizeAbs() { - SXRenderFunc::FullScreenChangeSizeAbs(); + rfunc::FullScreenChangeSizeAbs(); } \ No newline at end of file diff --git a/source/render/sxrender.h b/source/render/sxrender.h index 775d3f9e6b4a3a523f2f8190beef89fa1a6af8e4..e84d20c2078312d9e76cc62ff162d4b4262eeac3 100644 --- a/source/render/sxrender.h +++ b/source/render/sxrender.h @@ -33,9 +33,15 @@ See the license in LICENSE #endif #if defined(_DEBUG) -#pragma comment(lib, "sxmtllight_d.lib") +#pragma comment(lib, "sxlight_d.lib") #else -#pragma comment(lib, "sxmtllight.lib") +#pragma comment(lib, "sxlight.lib") +#endif + +#if defined(_DEBUG) +#pragma comment(lib, "sxmtrl_d.lib") +#else +#pragma comment(lib, "sxmtrl.lib") #endif #if defined(_DEBUG) @@ -72,7 +78,8 @@ See the license in LICENSE #define SX_LIB_API extern "C" __declspec (dllimport) #include #include -#include +#include +#include #include #include #include @@ -360,15 +367,15 @@ SX_LIB_API void SRender_ComLighting(DWORD timeDelta); //! объединение слоев прозрачности SX_LIB_API void SRender_UnionLayers(); -//! просчет тонмаппинга -SX_LIB_API void SRender_ComToneMapping(DWORD timeDelta); - //! отрисовка партиклов (эффектов) SX_LIB_API void SRender_RenderParticles(DWORD timeDelta); -//! отрисовка постпроцесса -SX_LIB_API void SRender_RenderPostProcess(DWORD timeDelta); +//! отрисовка основного постпроцесса +SX_LIB_API void SRender_RenderMainPostProcess(DWORD timeDelta); + +//! отрисовка финального (после gui) постпроцесса +SX_LIB_API void SRender_RenderFinalPostProcess(DWORD timeDelta); //! очистка регистров шейдеров (были случаи когда не инициаилизировав определенный регист в шейдере, шейдер брал то что было установлено до него) SX_LIB_API void SRender_ShaderRegisterData(); diff --git a/source/skyxengine.cpp b/source/skyxengine.cpp index 12f578b3bd3c16cfa11b9fc0702c9140de02e992..852d347168b99ad0fa1feb12b6462119277ba352 100644 --- a/source/skyxengine.cpp +++ b/source/skyxengine.cpp @@ -226,9 +226,9 @@ void SkyXEngine_Init(HWND hWnd3D, HWND hWndParent3D, const char * szCmdLine) SGCore_SetFunc_MtlSet(SkyXEngine_RFuncMtlSet); SGCore_SetFunc_MtlLoad(SkyXEngine_RFuncMtlLoad); - SGCore_SetFunc_MtlGetSort((g_func_mtl_get_sort)SML_MtlGetSort); - SGCore_SetFunc_MtlGroupRenderIsSingly((g_func_mtl_group_render_is_singly)SML_MtlGetTypeReflection); - SGCore_SetFunc_MtlGetPhysicType((g_func_mtl_get_physic_type)SML_MtlGetPhysicMaterial); + SGCore_SetFunc_MtlGetSort((g_func_mtl_get_sort)SMtrl_MtlGetSort); + SGCore_SetFunc_MtlGroupRenderIsSingly((g_func_mtl_group_render_is_singly)SMtrl_MtlGetTypeReflection); + SGCore_SetFunc_MtlGetPhysicType((g_func_mtl_get_physic_type)SMtrl_MtlGetPhysicMaterial); SGCore_SkyBoxCr(); #if !defined(SX_MATERIAL_EDITOR) @@ -249,20 +249,26 @@ void SkyXEngine_Init(HWND hWnd3D, HWND hWndParent3D, const char * szCmdLine) SGeom_0Create("sxgeom", false); SGeom_Dbg_Set(SkyXEngine_PrintfLog); + SGeom_GreenSetFncIntersect(SkyXEngine_RFuncGreenIntersect); LibReport(REPORT_MSG_LEVEL_NOTICE, "LIB geom initialized\n"); - SML_0Create("sxml", false); - SML_Dbg_Set(SkyXEngine_PrintfLog); + SLight_0Create("sxml", false); + SLight_Dbg_Set(SkyXEngine_PrintfLog); - //SML_LigthsCreatePoint(&float3(100, 10, 100), 100, &float3(10, 0, 10), false, false); + LibReport(REPORT_MSG_LEVEL_NOTICE, "LIB light initialized\n"); + + + SMtrl_0Create("sxml", false); + SMtrl_Dbg_Set(SkyXEngine_PrintfLog); + + LibReport(REPORT_MSG_LEVEL_NOTICE, "LIB mtrl initialized\n"); - LibReport(REPORT_MSG_LEVEL_NOTICE, "LIB mtllight initialized\n"); SPE_0Create("sxparticles", false); SPE_Dbg_Set(SkyXEngine_PrintfLog); SPE_SetFunc_ParticlesPhyCollision(SkyXEngine_RFuncParticlesPhyCollision); - SPE_RTDepthSet(SML_DSGetRT_ID(DS_RT_DEPTH)); + SPE_RTDepthSet(SGCore_GbufferGetRT_ID(DS_RT_DEPTH)); LibReport(REPORT_MSG_LEVEL_NOTICE, "LIB particles initialized\n"); @@ -272,11 +278,11 @@ void SkyXEngine_Init(HWND hWnd3D, HWND hWndParent3D, const char * szCmdLine) #if defined(SX_GAME) SPP_ChangeTexSun("fx_sun.dds"); #endif - SPP_RTSetInput(SML_DSGetRT_ID(DS_RT_SCENELIGHT)); - SPP_RTSetOutput(SML_DSGetRT_ID(DS_RT_SCENELIGHT2)); - SPP_RTSetDepth0(SML_DSGetRT_ID(DS_RT_DEPTH0)); - SPP_RTSetDepth1(SML_DSGetRT_ID(DS_RT_DEPTH1)); - SPP_RTSetNormal(SML_DSGetRT_ID(DS_RT_NORMAL)); + SPP_RTSetInput(SGCore_GbufferGetRT_ID(DS_RT_SCENELIGHT)); + SPP_RTSetOutput(SGCore_GbufferGetRT_ID(DS_RT_SCENELIGHT2)); + SPP_RTSetDepth0(SGCore_GbufferGetRT_ID(DS_RT_DEPTH0)); + SPP_RTSetDepth1(SGCore_GbufferGetRT_ID(DS_RT_DEPTH1)); + SPP_RTSetNormal(SGCore_GbufferGetRT_ID(DS_RT_NORMAL)); LibReport(REPORT_MSG_LEVEL_NOTICE, "LIB pp initialized\n"); @@ -769,7 +775,7 @@ void SkyXEngine_Frame(DWORD timeDelta) Core_RMatrixGet(G_RI_MATRIX_OBSERVER_VIEW, &mView); Core_RMatrixGet(G_RI_MATRIX_LIGHT_PROJ, &mProjLight); - SML_Update(timeDelta); + SMtrl_Update(timeDelta); pDXDevice->BeginScene(); pDXDevice->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0); @@ -802,15 +808,14 @@ void SkyXEngine_Frame(DWORD timeDelta) if (SGCore_SkyBoxIsCr()) SRender_RenderSky(timeDelta); - SRender_ComToneMapping(timeDelta); + static const float * r_hdr_adapted_coef = GET_PCVAR_FLOAT("r_hdr_adapted_coef"); + SGCore_ToneMappingCom(timeDelta, (r_hdr_adapted_coef ? (*r_hdr_adapted_coef) : 0.03f)); DelayComLighting += TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER)) - ttime; } SGCore_ShaderUnBind(); - SRender_RenderParticles(timeDelta); - pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); @@ -820,17 +825,52 @@ void SkyXEngine_Frame(DWORD timeDelta) #if defined(SX_GAME) ttime = TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER)); if (!SSInput_GetKeyState(SIK_P)) - SRender_RenderPostProcess(timeDelta); + SRender_RenderMainPostProcess(timeDelta); DelayPostProcess += TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER)) - ttime; #endif + + LPDIRECT3DSURFACE9 pRenderSurf, pBackBuf; + SGCore_RTGetTexture(SPP_RTGetCurrSend())->GetSurfaceLevel(0, &pRenderSurf); + + pDXDevice->GetRenderTarget(0, &pBackBuf); + pDXDevice->SetRenderTarget(0, pRenderSurf); + + SRender_RenderParticles(timeDelta); + +#if defined(SX_GAME) + SXGame_RenderHUD(); +#endif + +#if defined(SX_GAME) || defined(SX_LEVEL_EDITOR) + SXGame_Render(); +#endif + + SGCore_ShaderUnBind(); + + pDXDevice->SetRenderTarget(0, pBackBuf); + mem_release(pRenderSurf); + mem_release(pBackBuf); + + + pDXDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); + pDXDevice->SetRenderState(D3DRS_ZWRITEENABLE, D3DZB_FALSE); + pDXDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); + pDXDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); + pDXDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE); + +#if defined(SX_GAME) + SRender_RenderFinalPostProcess(timeDelta); +#endif + + SGCore_ShaderBindN(SHADER_TYPE_VERTEX, "pp_quad_render.vs"); SGCore_ShaderBindN(SHADER_TYPE_PIXEL, "pp_quad_render.ps"); pDXDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); #if !defined(SX_GAME) - pDXDevice->SetTexture(0, SML_DSGetRT((DS_RT)*r_final_image)); + pDXDevice->SetTexture(0, SGCore_GbufferGetRT((DS_RT)*r_final_image)); #else pDXDevice->SetTexture(0, SGCore_RTGetTexture(SPP_RTGetCurrSend())); #endif @@ -838,30 +878,23 @@ void SkyXEngine_Frame(DWORD timeDelta) SGCore_ScreenQuadDraw(); SGCore_ShaderUnBind(); - - SRender_RenderParticles(timeDelta); + pDXDevice->SetTransform(D3DTS_WORLD, &((D3DXMATRIX)SMMatrixIdentity())); pDXDevice->SetTransform(D3DTS_VIEW, &((D3DXMATRIX)mView)); pDXDevice->SetTransform(D3DTS_PROJECTION, &((D3DXMATRIX)mProjLight)); SRender_RenderEditorMain(); - #if defined(SX_GAME) && defined(SX_AIGRID_RENDER) //static const float * r_far = GET_PCVAR_FLOAT("r_far"); SAIG_RenderQuads(SRender_GetCamera()->getFrustum(), &vCamPos, *r_far); #endif -#if defined(SX_GAME) - SXGame_RenderHUD(); +#ifdef _DEBUG + SXPhysics_DebugRender(); #endif - - - - - #if defined(SX_GAME) || defined(SX_LEVEL_EDITOR) static bool needGameTime = true; #else @@ -922,13 +955,7 @@ void SkyXEngine_Frame(DWORD timeDelta) DelayPresent = 0; } -#ifdef _DEBUG - SXPhysics_DebugRender(); -#endif -#if defined(SX_GAME) || defined(SX_LEVEL_EDITOR) - SXGame_Render(); -#endif #if defined(SX_LEVEL_EDITOR) SXLevelEditor::LevelEditorUpdate(timeDelta); @@ -967,7 +994,7 @@ void SkyXEngine_Frame(DWORD timeDelta) ttime = TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER)); - SGCore_OC_Update(SML_DSGetRT_ID(DS_RT_DEPTH0), SRender_GetCamera()->getFrustum()); + SGCore_OC_Update(SGCore_GbufferGetRT_ID(DS_RT_DEPTH0), SRender_GetCamera()->getFrustum()); DelayUpdateOC += TimeGetMcsU(Core_RIntGet(G_RI_INT_TIMER_RENDER)) - ttime; @@ -1001,7 +1028,7 @@ void SkyXEngine_Frame(DWORD timeDelta) void SkyXEngind_UpdateDataCVar() { - ID idGlobalLight = SML_LigthsGetGlobal(); + ID idGlobalLight = SLight_GetGlobal(); static const bool * r_pssm_4or3 = GET_PCVAR_BOOL("r_pssm_4or3"); static bool r_pssm_4or3_old = true; @@ -1009,14 +1036,14 @@ void SkyXEngind_UpdateDataCVar() if (r_pssm_4or3 && r_pssm_4or3_old != (*r_pssm_4or3) && idGlobalLight >= 0) { r_pssm_4or3_old = (*r_pssm_4or3); - SML_LigthsSet4Or3SplitsG(idGlobalLight, r_pssm_4or3_old); + SLight_Set4Or3SplitsG(idGlobalLight, r_pssm_4or3_old); } static const bool * r_pssm_shadowed = GET_PCVAR_BOOL("r_pssm_shadowed"); if (r_pssm_shadowed && idGlobalLight >= 0) { - SML_LigthsSetTypeShadowed(idGlobalLight, ((*r_pssm_shadowed) ? LTYPE_SHADOW_DYNAMIC : LTYPE_SHADOW_NONE)); + SLight_SetTypeShadowed(idGlobalLight, ((*r_pssm_shadowed) ? LTYPE_SHADOW_DYNAMIC : LTYPE_SHADOW_NONE)); } static const float * r_pssm_quality = GET_PCVAR_FLOAT("r_pssm_quality"); @@ -1035,7 +1062,7 @@ void SkyXEngind_UpdateDataCVar() r_pssm_quality_old = 4.f; Core_0SetCVarFloat("r_pssm_quality", r_pssm_quality_old); } - SML_LigthsSettGCoefSizeDepth(r_pssm_quality_old); + SLight_SettGCoefSizeDepth(r_pssm_quality_old); } static const float * r_lsm_quality = GET_PCVAR_FLOAT("r_lsm_quality"); @@ -1054,7 +1081,7 @@ void SkyXEngind_UpdateDataCVar() r_lsm_quality_old = 4.f; Core_0SetCVarFloat("r_lsm_quality", r_lsm_quality_old); } - SML_LigthsSettLCoefSizeDepth(r_lsm_quality_old); + SLight_SettLCoefSizeDepth(r_lsm_quality_old); } static const int * r_grass_freq = GET_PCVAR_INT("r_grass_freq"); @@ -1336,7 +1363,7 @@ void SkyXEngine_Kill() SXAnim_AKill(); SGeom_AKill(); - SML_AKill(); + SLight_AKill(); SSCore_AKill(); SGCore_AKill(); Core_AKill(); @@ -1437,6 +1464,7 @@ void SkyXEngine_PreviewKill() g_hWinPreview = 0; } #endif + //########################################################################## void SkyXEngine_RFuncDIP(UINT type_primitive, long base_vertexIndex, UINT min_vertex_index, UINT num_vertices, UINT start_index, UINT prim_count) @@ -1449,26 +1477,26 @@ void SkyXEngine_RFuncMtlSet(ID id, float4x4* world) switch (Core_RIntGet(G_RI_INT_RENDERSTATE)) { case RENDER_STATE_SHADOW: - SML_MtlSetMainTexture(0, id); - SML_LigthsShadowSetShaderOfTypeMat(Core_RIntGet(G_RI_INT_CURRIDLIGHT), SML_MtlGetTypeModel(id), world); + SMtrl_MtlSetMainTexture(0, id); + SLight_ShadowSetShaderOfTypeMat(Core_RIntGet(G_RI_INT_CURRIDLIGHT), SMtrl_MtlGetTypeModel(id), world); break; case RENDER_STATE_FREE: - SML_MtlSetMainTexture(0, id); + SMtrl_MtlSetMainTexture(0, id); Core_RMatrixSet(G_RI_MATRIX_WORLD, &(world ? (*world) : SMMatrixIdentity())); //SGCore_ShaderUnBind(); - SML_MtlRenderStd(SML_MtlGetTypeModel(id), world, 0, id); + SMtrl_MtlRenderStd(SMtrl_MtlGetTypeModel(id), world, 0, id); break; case RENDER_STATE_MATERIAL: - SML_MtlRender(id, world); + SMtrl_MtlRender(id, world); break; } } ID SkyXEngine_RFuncMtlLoad(const char* name, int mtl_type) { - return SML_MtlLoad(name, (MTLTYPE_MODEL)mtl_type); + return SMtrl_MtlLoad(name, (MTLTYPE_MODEL)mtl_type); } bool SkyXEngine_RFuncAIQuadPhyNavigate(float3_t *pPos) @@ -1553,6 +1581,28 @@ bool SkyXEngine_RFuncParticlesPhyCollision(const float3 * lastpos, const float3* return false; } +bool SkyXEngine_RFuncGreenIntersect(const float3 *pStart, const float3 *pFinish, float3 *pResult) +{ + if (!pStart || !pFinish) + return false; + + float3 vDir = float3(0, -1, 0); + + btCollisionWorld::ClosestRayResultCallback cb(F3_BTVEC(*pStart), F3_BTVEC(*pFinish)); + SXPhysics_GetDynWorld()->rayTest(F3_BTVEC(*pStart), F3_BTVEC(*pFinish), cb); + + if (cb.hasHit()) + { + if (pResult) + *pResult = BTVEC_F3(cb.m_hitPointWorld); + + return true; + } + + return false; +} + +//########################################################################## IDirect3DTexture9* SkyXEngine_LoadAsPreviewData(const char *szPath) { diff --git a/source/sxleveleditor/green_callback.cpp b/source/sxleveleditor/green_callback.cpp index 4db307b0d2221f22a7802f3b4f95856161f93c2a..6c3862620e4137d7d0692139fb76af5620d2bd74 100644 --- a/source/sxleveleditor/green_callback.cpp +++ b/source/sxleveleditor/green_callback.cpp @@ -194,7 +194,6 @@ LRESULT SXLevelEditor_ButtonGreenMask_Click(HWND hwnd, UINT msg, WPARAM wParam, if (gui_func::dialogs::SelectFileOwn(tmpname, tmppath, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), "dds", "Select texture mask", true, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), SXLevelEditor::JobWindow->getHWND(), SkyXEngine_EditorHandlerGetPreviewData, SkyXEngine_EditorHandlerGetTextureInfo)) { - StrCutName(tmppath, tmpname); SXLevelEditor::EditGreenMask->setText(tmpname); } return 0; @@ -343,6 +342,8 @@ LRESULT SXLevelEditor_ButtonGreenGenerate_Click(HWND hwnd, UINT msg, WPARAM wPar float pos = SXLevelEditor::TrackBarGreenDensity->getPos(); + SXPhysics_LoadGeom(NULL); + SGeom_GreenAddGreen(tmp_name, tmp_tex, pos, diff --git a/source/sxmaterialeditor/buttons_callback.cpp b/source/sxmaterialeditor/buttons_callback.cpp index fe9d3955ebfcedbbab70ee0da3cbbe874e1f5590..1ea94e411216d39b9f6bcde0eeac0c5a283ffa12 100644 --- a/source/sxmaterialeditor/buttons_callback.cpp +++ b/source/sxmaterialeditor/buttons_callback.cpp @@ -31,9 +31,9 @@ LRESULT SXMaterialEditor_ButtonLigthColor_Click(HWND hwnd, UINT msg, WPARAM wPar oChooseColor.lpCustColors = aCustClr; oChooseColor.Flags = CC_FULLOPEN | CC_RGBINIT; - ID idGlobalLight = SML_LigthsGetGlobal(); + ID idGlobalLight = SLight_GetGlobal(); float3 vColor; - SML_LigthsGetColor(idGlobalLight, &vColor); + SLight_GetColor(idGlobalLight, &vColor); oChooseColor.rgbResult = RGB(DWORD(vColor.x * 255.0), DWORD(vColor.y * 255.0), DWORD(vColor.z * 255.0)); @@ -42,7 +42,7 @@ LRESULT SXMaterialEditor_ButtonLigthColor_Click(HWND hwnd, UINT msg, WPARAM wPar vColor.x = float(GetRValue(oChooseColor.rgbResult)) / 255.0; vColor.y = float(GetGValue(oChooseColor.rgbResult)) / 255.0; vColor.z = float(GetBValue(oChooseColor.rgbResult)) / 255.0; - SML_LigthsSetColor(idGlobalLight, &vColor); + SLight_SetColor(idGlobalLight, &vColor); SXMaterialEditor::pStaticLigthColor->setColorBrush(oChooseColor.rgbResult); SXMaterialEditor::pEditLigthColorR->setText(String(vColor.x).c_str()); @@ -65,7 +65,7 @@ LRESULT SXMaterialEditor_ButtonTex_Click(HWND hwnd, UINT msg, WPARAM wParam, LPA //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditTex->setText(tmpname); - SML_MtlSetTexture(SXMaterialEditor::idMat, tmpname); + SMtrl_MtlSetTexture(SXMaterialEditor::idMat, tmpname); } return 0; } @@ -82,7 +82,7 @@ LRESULT SXMaterialEditor_ButtonVS_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditVS->setText(tmpname); - SML_MtlSetVS(SXMaterialEditor::idMat, tmpname); + SMtrl_MtlSetVS(SXMaterialEditor::idMat, tmpname); } return 0; } @@ -99,7 +99,7 @@ LRESULT SXMaterialEditor_ButtonPS_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditPS->setText(tmpname); - SML_MtlSetPS(SXMaterialEditor::idMat, tmpname); + SMtrl_MtlSetPS(SXMaterialEditor::idMat, tmpname); } return 0; } @@ -115,7 +115,7 @@ LRESULT SXMaterialEditor_ButtonTexLighting_Click(HWND hwnd, UINT msg, WPARAM wPa //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditTexLighting->setText(tmpname); - SML_MtlSetTextureLighting(SXMaterialEditor::idMat, tmpname); + SMtrl_MtlSetTextureLighting(SXMaterialEditor::idMat, tmpname); } return 0; } @@ -131,7 +131,7 @@ LRESULT SXMaterialEditor_ButtonMask_Click(HWND hwnd, UINT msg, WPARAM wParam, LP //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditMask->setText(tmpname); - SML_MtlSetMaskTex(SXMaterialEditor::idMat, tmpname); + SMtrl_MtlSetMaskTex(SXMaterialEditor::idMat, tmpname); } return 0; } @@ -147,7 +147,7 @@ LRESULT SXMaterialEditor_ButtonMR_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditMR->setText(tmpname); - SML_MtlSetMRTex(SXMaterialEditor::idMat, 0, tmpname); + SMtrl_MtlSetMRTex(SXMaterialEditor::idMat, 0, tmpname); } return 0; } @@ -163,7 +163,7 @@ LRESULT SXMaterialEditor_ButtonMG_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditMG->setText(tmpname); - SML_MtlSetMRTex(SXMaterialEditor::idMat, 1, tmpname); + SMtrl_MtlSetMRTex(SXMaterialEditor::idMat, 1, tmpname); } return 0; } @@ -179,7 +179,7 @@ LRESULT SXMaterialEditor_ButtonMB_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditMB->setText(tmpname); - SML_MtlSetMRTex(SXMaterialEditor::idMat, 2, tmpname); + SMtrl_MtlSetMRTex(SXMaterialEditor::idMat, 2, tmpname); } return 0; } @@ -195,7 +195,7 @@ LRESULT SXMaterialEditor_ButtonMA_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditMA->setText(tmpname); - SML_MtlSetMRTex(SXMaterialEditor::idMat, 3, tmpname); + SMtrl_MtlSetMRTex(SXMaterialEditor::idMat, 3, tmpname); } return 0; } @@ -212,7 +212,7 @@ LRESULT SXMaterialEditor_ButtonDR_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditDR->setText(tmpname); - SML_MtlSetDTex(SXMaterialEditor::idMat, 0, tmpname); + SMtrl_MtlSetDTex(SXMaterialEditor::idMat, 0, tmpname); } return 0; } @@ -228,7 +228,7 @@ LRESULT SXMaterialEditor_ButtonDG_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditDG->setText(tmpname); - SML_MtlSetDTex(SXMaterialEditor::idMat, 1, tmpname); + SMtrl_MtlSetDTex(SXMaterialEditor::idMat, 1, tmpname); } return 0; } @@ -244,7 +244,7 @@ LRESULT SXMaterialEditor_ButtonDB_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditDB->setText(tmpname); - SML_MtlSetDTex(SXMaterialEditor::idMat, 2, tmpname); + SMtrl_MtlSetDTex(SXMaterialEditor::idMat, 2, tmpname); } return 0; } @@ -260,7 +260,7 @@ LRESULT SXMaterialEditor_ButtonDA_Click(HWND hwnd, UINT msg, WPARAM wParam, LPAR //StrCutName(tmppath, tmpname); SXMaterialEditor::pEditDA->setText(tmpname); - SML_MtlSetDTex(SXMaterialEditor::idMat, 3, tmpname); + SMtrl_MtlSetDTex(SXMaterialEditor::idMat, 3, tmpname); } return 0; } \ No newline at end of file diff --git a/source/sxmaterialeditor/buttons_callback.h b/source/sxmaterialeditor/buttons_callback.h index 5ca127dc9d210edcfa2b05304a57562214349c84..c06d69af832a35bffc87bff6703ed19db4d2cb19 100644 --- a/source/sxmaterialeditor/buttons_callback.h +++ b/source/sxmaterialeditor/buttons_callback.h @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include #include diff --git a/source/sxmaterialeditor/common_callback.cpp b/source/sxmaterialeditor/common_callback.cpp index 98d3d22dd0c6c4f29462e00d32936ce265758825..25b852a37196c8deeacae696ecdac4e5aa7ee004 100644 --- a/source/sxmaterialeditor/common_callback.cpp +++ b/source/sxmaterialeditor/common_callback.cpp @@ -17,8 +17,8 @@ void SXMaterialEditor::MtlOpen() //gui_func::dialogs::SelectFile(SXGUI_DIALOG_FILE_OPEN, tmppath, 0, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), FILE_FILTER_TEXTURE); if (gui_func::dialogs::SelectFileOwn(tmpname, tmppath, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), "dds", "Select textures", true, Core_RStringGet(G_RI_STRING_PATH_GS_TEXTURES), SXMaterialEditor::pJobWindow->getHWND(), SkyXEngine_EditorHandlerGetPreviewData, SkyXEngine_EditorHandlerGetTextureInfo)) { - SML_MtlReloadMaterial(SRender_SimModelGetIDMtl(), tmpname); - SML_MtlSetIsTextureLighting(SRender_SimModelGetIDMtl(), false); + SMtrl_MtlReloadMaterial(SRender_SimModelGetIDMtl(), tmpname); + SMtrl_MtlSetIsTextureLighting(SRender_SimModelGetIDMtl(), false); SGCore_LoadTexAllLoad(); char headertest[1024]; @@ -30,7 +30,7 @@ void SXMaterialEditor::MtlOpen() void SXMaterialEditor::MtlSave() { - SML_MtlSave(SXMaterialEditor::idMat); + SMtrl_MtlSave(SXMaterialEditor::idMat); } LRESULT ComMenuId(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) @@ -192,107 +192,107 @@ LRESULT SXMaterialEditor_JobWindow_CallWmCommand(HWND hwnd, UINT msg, WPARAM wPa HWND handle_elem = (HWND)(lParam); if (SXMaterialEditor::pCheckBoxLighting->getHWND() == handle_elem) { - SML_MtlSetLighting(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxLighting->getCheck()); + SMtrl_MtlSetLighting(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxLighting->getCheck()); } else if (SXMaterialEditor::pCheckBoxTransparent->getHWND() == handle_elem) { - SML_MtlSetTransparency(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxTransparent->getCheck()); + SMtrl_MtlSetTransparency(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxTransparent->getCheck()); } else if (SXMaterialEditor::pCheckBoxTexLighting->getHWND() == handle_elem) { - SML_MtlSetIsTextureLighting(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxTexLighting->getCheck()); + SMtrl_MtlSetIsTextureLighting(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxTexLighting->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSVVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_VIEW, SXMaterialEditor::pCheckBoxDoSVVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_VIEW, SXMaterialEditor::pCheckBoxDoSVVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSWVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLD, SXMaterialEditor::pCheckBoxDoSWVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLD, SXMaterialEditor::pCheckBoxDoSWVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSWPS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLD, SXMaterialEditor::pCheckBoxDoSWPS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLD, SXMaterialEditor::pCheckBoxDoSWPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSVPS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_VIEW, SXMaterialEditor::pCheckBoxDoSVPS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_VIEW, SXMaterialEditor::pCheckBoxDoSVPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSPVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_PROJECTION, SXMaterialEditor::pCheckBoxDoSPVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_PROJECTION, SXMaterialEditor::pCheckBoxDoSPVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSPPS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_PROJECTION, SXMaterialEditor::pCheckBoxDoSPPS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_PROJECTION, SXMaterialEditor::pCheckBoxDoSPPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSWVVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLDVIEW, SXMaterialEditor::pCheckBoxDoSWVVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLDVIEW, SXMaterialEditor::pCheckBoxDoSWVVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSWVPS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLDVIEW, SXMaterialEditor::pCheckBoxDoSWVPS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLDVIEW, SXMaterialEditor::pCheckBoxDoSWVPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSCamposVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_CAMPOS, SXMaterialEditor::pCheckBoxDoSCamposVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_CAMPOS, SXMaterialEditor::pCheckBoxDoSCamposVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSWVPVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ, SXMaterialEditor::pCheckBoxDoSWVPVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ, SXMaterialEditor::pCheckBoxDoSWVPVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSWVPPS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ, SXMaterialEditor::pCheckBoxDoSWVPPS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ, SXMaterialEditor::pCheckBoxDoSWVPPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSCamposPS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_CAMPOS, SXMaterialEditor::pCheckBoxDoSCamposPS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_CAMPOS, SXMaterialEditor::pCheckBoxDoSCamposPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxUDVSInPS->getHWND() == handle_elem) { - SML_MtlSetUserDataVS_InPS(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxUDVSInPS->getCheck()); + SMtrl_MtlSetUserDataVS_InPS(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxUDVSInPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSTimeDeltaVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_TIMEDELTA, SXMaterialEditor::pCheckBoxDoSTimeDeltaVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_TIMEDELTA, SXMaterialEditor::pCheckBoxDoSTimeDeltaVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSTimeDeltaPS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_TIMEDELTA, SXMaterialEditor::pCheckBoxDoSTimeDeltaPS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_TIMEDELTA, SXMaterialEditor::pCheckBoxDoSTimeDeltaPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSWinSizeVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_WINSIZE, SXMaterialEditor::pCheckBoxDoSWinSizeVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_WINSIZE, SXMaterialEditor::pCheckBoxDoSWinSizeVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxDoSWinSizePS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_WINSIZE, SXMaterialEditor::pCheckBoxDoSWinSizePS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_WINSIZE, SXMaterialEditor::pCheckBoxDoSWinSizePS->getCheck()); } else if (SXMaterialEditor::pCheckBoxUDPSInVS->getHWND() == handle_elem) { - SML_MtlSetUserDataPS_InVS(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxUDPSInVS->getCheck()); + SMtrl_MtlSetUserDataPS_InVS(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxUDPSInVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxUDVS->getHWND() == handle_elem) { - SML_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_USERDATA, SXMaterialEditor::pCheckBoxUDVS->getCheck()); + SMtrl_MtlSetStdVS(SXMaterialEditor::idMat, MTL_SHADERSTD_USERDATA, SXMaterialEditor::pCheckBoxUDVS->getCheck()); } else if (SXMaterialEditor::pCheckBoxUDPS->getHWND() == handle_elem) { - SML_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_USERDATA, SXMaterialEditor::pCheckBoxUDPS->getCheck()); + SMtrl_MtlSetStdPS(SXMaterialEditor::idMat, MTL_SHADERSTD_USERDATA, SXMaterialEditor::pCheckBoxUDPS->getCheck()); } else if (SXMaterialEditor::pCheckBoxAlphaTest->getHWND() == handle_elem) { - SML_MtlSetUsingAlphaTest(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxAlphaTest->getCheck()); + SMtrl_MtlSetUsingAlphaTest(SXMaterialEditor::idMat, SXMaterialEditor::pCheckBoxAlphaTest->getCheck()); } } else if (Notification == CBN_SELCHANGE) @@ -301,7 +301,7 @@ LRESULT SXMaterialEditor_JobWindow_CallWmCommand(HWND hwnd, UINT msg, WPARAM wPa if (SXMaterialEditor::pComboBoxTypeModel->getHWND() == handle_elem) { SRender_SimModelSetType((MTLTYPE_MODEL)SXMaterialEditor::pComboBoxTypeModel->getSel()); - SML_MtlSetTypeModel(SRender_SimModelGetIDMtl(), (MTLTYPE_MODEL)SXMaterialEditor::pComboBoxTypeModel->getSel()); + SMtrl_MtlSetTypeModel(SRender_SimModelGetIDMtl(), (MTLTYPE_MODEL)SXMaterialEditor::pComboBoxTypeModel->getSel()); } else if (SXMaterialEditor::pComboBoxTestModel->getHWND() == handle_elem) { @@ -309,15 +309,15 @@ LRESULT SXMaterialEditor_JobWindow_CallWmCommand(HWND hwnd, UINT msg, WPARAM wPa } /*else if (SXMaterialEditor::pComboBoxTypeRefract->getHWND() == handle_elem) { - SML_MtlSetTypeTransparency(SXMaterialEditor::idMat, (MTLTYPE_TRANSPARENCY)SXMaterialEditor::pComboBoxTypeRefract->getSel()); + SMtrl_MtlSetTypeTransparency(SXMaterialEditor::idMat, (MTLTYPE_TRANSPARENCY)SXMaterialEditor::pComboBoxTypeRefract->getSel()); }*/ else if (SXMaterialEditor::pComboBoxTypeReflect->getHWND() == handle_elem) { - SML_MtlSetTypeReflection(SXMaterialEditor::idMat, (MTLTYPE_REFLECT)SXMaterialEditor::pComboBoxTypeReflect->getSel()); + SMtrl_MtlSetTypeReflection(SXMaterialEditor::idMat, (MTLTYPE_REFLECT)SXMaterialEditor::pComboBoxTypeReflect->getSel()); } else if (SXMaterialEditor::pComboBoxPhysic->getHWND() == handle_elem) { - SML_MtlSetPhysicMaterial(SXMaterialEditor::idMat, (MTLTYPE_PHYSIC)SXMaterialEditor::pComboBoxPhysic->getSel()); + SMtrl_MtlSetPhysicMaterial(SXMaterialEditor::idMat, (MTLTYPE_PHYSIC)SXMaterialEditor::pComboBoxPhysic->getSel()); } else if (SXMaterialEditor::pComboBoxShaders->getHWND() == handle_elem) { @@ -325,10 +325,10 @@ LRESULT SXMaterialEditor_JobWindow_CallWmCommand(HWND hwnd, UINT msg, WPARAM wPa if (sel > 0) { sel -= 1; - SML_MtlSetVS(SXMaterialEditor::idMat, SXMaterialEditor::pShaders->getVS(sel)); + SMtrl_MtlSetVS(SXMaterialEditor::idMat, SXMaterialEditor::pShaders->getVS(sel)); SXMaterialEditor::pEditVS->setText(SXMaterialEditor::pShaders->getVS(sel)); - SML_MtlSetPS(SXMaterialEditor::idMat, SXMaterialEditor::pShaders->getPS(sel)); + SMtrl_MtlSetPS(SXMaterialEditor::idMat, SXMaterialEditor::pShaders->getPS(sel)); SXMaterialEditor::pEditPS->setText(SXMaterialEditor::pShaders->getPS(sel)); } } @@ -338,15 +338,15 @@ LRESULT SXMaterialEditor_JobWindow_CallWmCommand(HWND hwnd, UINT msg, WPARAM wPa if (sel > 0) { sel -= 1; - SML_MtlSetThickness(SXMaterialEditor::idMat, SXMaterialEditor::pParamL->getThickness(sel)); + SMtrl_MtlSetThickness(SXMaterialEditor::idMat, SXMaterialEditor::pParamL->getThickness(sel)); SXMaterialEditor::pEditThickness->setText(String(SXMaterialEditor::pParamL->getThickness(sel)).c_str()); SXMaterialEditor::pTrackBarThickness->setPos(SXMaterialEditor::pParamL->getThickness(sel)*100); - SML_MtlSetRoughness(SXMaterialEditor::idMat, SXMaterialEditor::pParamL->getRoughness(sel)); + SMtrl_MtlSetRoughness(SXMaterialEditor::idMat, SXMaterialEditor::pParamL->getRoughness(sel)); SXMaterialEditor::pEditRoughness->setText(String(SXMaterialEditor::pParamL->getRoughness(sel)).c_str()); SXMaterialEditor::pTrackBarRoughness->setPos(SXMaterialEditor::pParamL->getRoughness(sel) * 100); - SML_MtlSetF0(SXMaterialEditor::idMat, SXMaterialEditor::pParamL->getF0(sel)); + SMtrl_MtlSetF0(SXMaterialEditor::idMat, SXMaterialEditor::pParamL->getF0(sel)); SXMaterialEditor::pEditF0->setText(String(SXMaterialEditor::pParamL->getF0(sel)).c_str()); SXMaterialEditor::pTrackBarF0->setPos(SXMaterialEditor::pParamL->getF0(sel) * 100); } @@ -448,127 +448,127 @@ void SXMaterialEditor::Nulling() void SXMaterialEditor::InitMtl(ID id) { - SRender_SimModelSetType(SML_MtlGetTypeModel(id)); - SXMaterialEditor::pComboBoxTypeModel->setSel(SML_MtlGetTypeModel(id)); + SRender_SimModelSetType(SMtrl_MtlGetTypeModel(id)); + SXMaterialEditor::pComboBoxTypeModel->setSel(SMtrl_MtlGetTypeModel(id)); SXMaterialEditor::pComboBoxTestModel; - SXMaterialEditor::pComboBoxPhysic->setSel(SML_MtlGetPhysicMaterial(SRender_SimModelGetIDMtl())); + SXMaterialEditor::pComboBoxPhysic->setSel(SMtrl_MtlGetPhysicMaterial(SRender_SimModelGetIDMtl())); char tmppath[1024]; - SML_MtlGetTexture(SRender_SimModelGetIDMtl(), tmppath); + SMtrl_MtlGetTexture(SRender_SimModelGetIDMtl(), tmppath); SXMaterialEditor::pEditTex->setText(tmppath); - SML_MtlGetVS(SRender_SimModelGetIDMtl(), tmppath); + SMtrl_MtlGetVS(SRender_SimModelGetIDMtl(), tmppath); SXMaterialEditor::pEditVS->setText(tmppath); - SML_MtlGetPS(SRender_SimModelGetIDMtl(), tmppath); + SMtrl_MtlGetPS(SRender_SimModelGetIDMtl(), tmppath); SXMaterialEditor::pEditPS->setText(tmppath); - SXMaterialEditor::pCheckBoxAlphaTest->setCheck(SML_MtlGetUsingAlphaTest(SRender_SimModelGetIDMtl())); + SXMaterialEditor::pCheckBoxAlphaTest->setCheck(SMtrl_MtlGetUsingAlphaTest(SRender_SimModelGetIDMtl())); - SXMaterialEditor::pEditRoughness->setText(String(SML_MtlGetRoughness(SRender_SimModelGetIDMtl())).c_str()); - SXMaterialEditor::pEditThickness->setText(String(SML_MtlGetThickness(SRender_SimModelGetIDMtl())).c_str()); - SXMaterialEditor::pEditF0->setText(String(SML_MtlGetF0(SRender_SimModelGetIDMtl())).c_str()); - SXMaterialEditor::pEditHitChance->setText(String(SML_MtlGetHitChance(SRender_SimModelGetIDMtl())).c_str()); - SXMaterialEditor::pEditDurability->setText(String(SML_MtlGetDurability(SRender_SimModelGetIDMtl())).c_str()); - SXMaterialEditor::pEditDensity->setText(String(SML_MtlGetDensity(SRender_SimModelGetIDMtl())).c_str()); + SXMaterialEditor::pEditRoughness->setText(String(SMtrl_MtlGetRoughness(SRender_SimModelGetIDMtl())).c_str()); + SXMaterialEditor::pEditThickness->setText(String(SMtrl_MtlGetThickness(SRender_SimModelGetIDMtl())).c_str()); + SXMaterialEditor::pEditF0->setText(String(SMtrl_MtlGetF0(SRender_SimModelGetIDMtl())).c_str()); + SXMaterialEditor::pEditHitChance->setText(String(SMtrl_MtlGetHitChance(SRender_SimModelGetIDMtl())).c_str()); + SXMaterialEditor::pEditDurability->setText(String(SMtrl_MtlGetDurability(SRender_SimModelGetIDMtl())).c_str()); + SXMaterialEditor::pEditDensity->setText(String(SMtrl_MtlGetDensity(SRender_SimModelGetIDMtl())).c_str()); - SXMaterialEditor::pCheckBoxLighting->setCheck(SML_MtlGetLighting(SRender_SimModelGetIDMtl())); + SXMaterialEditor::pCheckBoxLighting->setCheck(SMtrl_MtlGetLighting(SRender_SimModelGetIDMtl())); - SXMaterialEditor::pCheckBoxTransparent->setCheck(SML_MtlGetTransparency(SRender_SimModelGetIDMtl())); + SXMaterialEditor::pCheckBoxTransparent->setCheck(SMtrl_MtlGetTransparency(SRender_SimModelGetIDMtl())); - SXMaterialEditor::pTrackBarRoughness->setPos(SML_MtlGetRoughness(SRender_SimModelGetIDMtl())*100.f); - SXMaterialEditor::pTrackBarThickness->setPos(SML_MtlGetThickness(SRender_SimModelGetIDMtl())*100.f); - SXMaterialEditor::pTrackBarF0->setPos(SML_MtlGetF0(SRender_SimModelGetIDMtl()) * 100.f); - SXMaterialEditor::pTrackBarHitChance->setPos(SML_MtlGetHitChance(SRender_SimModelGetIDMtl()) * 100.f); + SXMaterialEditor::pTrackBarRoughness->setPos(SMtrl_MtlGetRoughness(SRender_SimModelGetIDMtl())*100.f); + SXMaterialEditor::pTrackBarThickness->setPos(SMtrl_MtlGetThickness(SRender_SimModelGetIDMtl())*100.f); + SXMaterialEditor::pTrackBarF0->setPos(SMtrl_MtlGetF0(SRender_SimModelGetIDMtl()) * 100.f); + SXMaterialEditor::pTrackBarHitChance->setPos(SMtrl_MtlGetHitChance(SRender_SimModelGetIDMtl()) * 100.f); - SML_MtlGetTextureLighting(SRender_SimModelGetIDMtl(), tmppath); + SMtrl_MtlGetTextureLighting(SRender_SimModelGetIDMtl(), tmppath); SXMaterialEditor::pEditTexLighting->setText(tmppath); - SXMaterialEditor::pCheckBoxTexLighting->setCheck(SML_MtlGetIsTextureLighting(SRender_SimModelGetIDMtl())); + SXMaterialEditor::pCheckBoxTexLighting->setCheck(SMtrl_MtlGetIsTextureLighting(SRender_SimModelGetIDMtl())); - SXMaterialEditor::pComboBoxTypeReflect->setSel(SML_MtlGetTypeReflection(SRender_SimModelGetIDMtl())); + SXMaterialEditor::pComboBoxTypeReflect->setSel(SMtrl_MtlGetTypeReflection(SRender_SimModelGetIDMtl())); SXMaterialEditor::pComboBoxPhysic->setSel(0); - SML_MtlGetMaskTex(SRender_SimModelGetIDMtl(), tmppath); + SMtrl_MtlGetMaskTex(SRender_SimModelGetIDMtl(), tmppath); SXMaterialEditor::pEditMask->setText(tmppath); - SML_MtlGetMRTex(SRender_SimModelGetIDMtl(), 0, tmppath); + SMtrl_MtlGetMRTex(SRender_SimModelGetIDMtl(), 0, tmppath); SXMaterialEditor::pEditMR->setText(tmppath); - SML_MtlGetMRTex(SRender_SimModelGetIDMtl(), 1, tmppath); + SMtrl_MtlGetMRTex(SRender_SimModelGetIDMtl(), 1, tmppath); SXMaterialEditor::pEditMG->setText(tmppath); - SML_MtlGetMRTex(SRender_SimModelGetIDMtl(), 2, tmppath); + SMtrl_MtlGetMRTex(SRender_SimModelGetIDMtl(), 2, tmppath); SXMaterialEditor::pEditMB->setText(tmppath); - SML_MtlGetMRTex(SRender_SimModelGetIDMtl(), 3, tmppath); + SMtrl_MtlGetMRTex(SRender_SimModelGetIDMtl(), 3, tmppath); SXMaterialEditor::pEditMA->setText(tmppath); - SML_MtlGetDTex(SRender_SimModelGetIDMtl(), 0, tmppath); + SMtrl_MtlGetDTex(SRender_SimModelGetIDMtl(), 0, tmppath); SXMaterialEditor::pEditDR->setText(tmppath); - SML_MtlGetDTex(SRender_SimModelGetIDMtl(), 1, tmppath); + SMtrl_MtlGetDTex(SRender_SimModelGetIDMtl(), 1, tmppath); SXMaterialEditor::pEditDG->setText(tmppath); - SML_MtlGetDTex(SRender_SimModelGetIDMtl(), 2, tmppath); + SMtrl_MtlGetDTex(SRender_SimModelGetIDMtl(), 2, tmppath); SXMaterialEditor::pEditDB->setText(tmppath); - SML_MtlGetDTex(SRender_SimModelGetIDMtl(), 3, tmppath); + SMtrl_MtlGetDTex(SRender_SimModelGetIDMtl(), 3, tmppath); SXMaterialEditor::pEditDA->setText(tmppath); - SXMaterialEditor::pCheckBoxDoSWVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLD)); - SXMaterialEditor::pCheckBoxDoSWPS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLD)); + SXMaterialEditor::pCheckBoxDoSWVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLD)); + SXMaterialEditor::pCheckBoxDoSWPS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLD)); - SXMaterialEditor::pCheckBoxDoSVVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_VIEW)); - SXMaterialEditor::pCheckBoxDoSVPS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_VIEW)); + SXMaterialEditor::pCheckBoxDoSVVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_VIEW)); + SXMaterialEditor::pCheckBoxDoSVPS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_VIEW)); - SXMaterialEditor::pCheckBoxDoSPVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_PROJECTION)); - SXMaterialEditor::pCheckBoxDoSPPS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_PROJECTION)); + SXMaterialEditor::pCheckBoxDoSPVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_PROJECTION)); + SXMaterialEditor::pCheckBoxDoSPPS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_PROJECTION)); - SXMaterialEditor::pCheckBoxDoSWVVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLDVIEW)); - SXMaterialEditor::pCheckBoxDoSWVPS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLDVIEW)); + SXMaterialEditor::pCheckBoxDoSWVVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLDVIEW)); + SXMaterialEditor::pCheckBoxDoSWVPS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLDVIEW)); - SXMaterialEditor::pCheckBoxDoSCamposVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_CAMPOS)); - SXMaterialEditor::pCheckBoxDoSCamposPS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_CAMPOS)); + SXMaterialEditor::pCheckBoxDoSCamposVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_CAMPOS)); + SXMaterialEditor::pCheckBoxDoSCamposPS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_CAMPOS)); - SXMaterialEditor::pCheckBoxDoSTimeDeltaVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_TIMEDELTA)); - SXMaterialEditor::pCheckBoxDoSTimeDeltaPS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_TIMEDELTA)); + SXMaterialEditor::pCheckBoxDoSTimeDeltaVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_TIMEDELTA)); + SXMaterialEditor::pCheckBoxDoSTimeDeltaPS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_TIMEDELTA)); - SXMaterialEditor::pCheckBoxDoSWVPVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ)); - SXMaterialEditor::pCheckBoxDoSWVPPS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ)); + SXMaterialEditor::pCheckBoxDoSWVPVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ)); + SXMaterialEditor::pCheckBoxDoSWVPPS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_MATRIX_WORLDVIEWPROJ)); - SXMaterialEditor::pCheckBoxDoSWinSizeVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_WINSIZE)); - SXMaterialEditor::pCheckBoxDoSWinSizePS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_WINSIZE)); + SXMaterialEditor::pCheckBoxDoSWinSizeVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_WINSIZE)); + SXMaterialEditor::pCheckBoxDoSWinSizePS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_WINSIZE)); - SXMaterialEditor::pCheckBoxUDVS->setCheck(SML_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_USERDATA)); - SXMaterialEditor::pCheckBoxUDPS->setCheck(SML_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_USERDATA)); + SXMaterialEditor::pCheckBoxUDVS->setCheck(SMtrl_MtlGetStdVS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_USERDATA)); + SXMaterialEditor::pCheckBoxUDPS->setCheck(SMtrl_MtlGetStdPS(SRender_SimModelGetIDMtl(), MTL_SHADERSTD_USERDATA)); // // SXMaterialEditor::pCheckBoxUDVSInPS->setCheck(false); - SXMaterialEditor::pTrackBarUDVSX->setPos(SML_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 0) * 100.f); - SXMaterialEditor::pEditUDVSX->setText(String(SML_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 0)).c_str()); + SXMaterialEditor::pTrackBarUDVSX->setPos(SMtrl_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 0) * 100.f); + SXMaterialEditor::pEditUDVSX->setText(String(SMtrl_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 0)).c_str()); - SXMaterialEditor::pTrackBarUDVSY->setPos(SML_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 1) * 100.f); - SXMaterialEditor::pEditUDVSY->setText(String(SML_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 1)).c_str()); + SXMaterialEditor::pTrackBarUDVSY->setPos(SMtrl_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 1) * 100.f); + SXMaterialEditor::pEditUDVSY->setText(String(SMtrl_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 1)).c_str()); - SXMaterialEditor::pTrackBarUDVSZ->setPos(SML_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 2) * 100.f); - SXMaterialEditor::pEditUDVSZ->setText(String(SML_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 2)).c_str()); + SXMaterialEditor::pTrackBarUDVSZ->setPos(SMtrl_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 2) * 100.f); + SXMaterialEditor::pEditUDVSZ->setText(String(SMtrl_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 2)).c_str()); - SXMaterialEditor::pTrackBarUDVSW->setPos(SML_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 3) * 100.f); - SXMaterialEditor::pEditUDVSW->setText(String(SML_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 3)).c_str()); + SXMaterialEditor::pTrackBarUDVSW->setPos(SMtrl_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 3) * 100.f); + SXMaterialEditor::pEditUDVSW->setText(String(SMtrl_MtlGetUserDataVS(SRender_SimModelGetIDMtl(), 3)).c_str()); SXMaterialEditor::pCheckBoxUDPSInVS->setCheck(false); - SXMaterialEditor::pTrackBarUDPSX->setPos(SML_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 0) * 100.f); - SXMaterialEditor::pEditUDPSX->setText(String(SML_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 0)).c_str()); + SXMaterialEditor::pTrackBarUDPSX->setPos(SMtrl_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 0) * 100.f); + SXMaterialEditor::pEditUDPSX->setText(String(SMtrl_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 0)).c_str()); - SXMaterialEditor::pTrackBarUDPSY->setPos(SML_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 1) * 100.f); - SXMaterialEditor::pEditUDPSY->setText(String(SML_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 1)).c_str()); + SXMaterialEditor::pTrackBarUDPSY->setPos(SMtrl_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 1) * 100.f); + SXMaterialEditor::pEditUDPSY->setText(String(SMtrl_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 1)).c_str()); - SXMaterialEditor::pTrackBarUDPSZ->setPos(SML_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 2) * 100.f); - SXMaterialEditor::pEditUDPSZ->setText(String(SML_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 2)).c_str()); + SXMaterialEditor::pTrackBarUDPSZ->setPos(SMtrl_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 2) * 100.f); + SXMaterialEditor::pEditUDPSZ->setText(String(SMtrl_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 2)).c_str()); - SXMaterialEditor::pTrackBarUDPSW->setPos(SML_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 3) * 100.f); - SXMaterialEditor::pEditUDPSW->setText(String(SML_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 3)).c_str()); + SXMaterialEditor::pTrackBarUDPSW->setPos(SMtrl_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 3) * 100.f); + SXMaterialEditor::pEditUDPSW->setText(String(SMtrl_MtlGetUserDataPS(SRender_SimModelGetIDMtl(), 3)).c_str()); - SXMaterialEditor::pCheckBoxUDPSInVS->setCheck(SML_MtlGetUserDataPS_InVS(SRender_SimModelGetIDMtl())); - SXMaterialEditor::pCheckBoxUDVSInPS->setCheck(SML_MtlGetUserDataVS_InPS(SRender_SimModelGetIDMtl())); + SXMaterialEditor::pCheckBoxUDPSInVS->setCheck(SMtrl_MtlGetUserDataPS_InVS(SRender_SimModelGetIDMtl())); + SXMaterialEditor::pCheckBoxUDVSInPS->setCheck(SMtrl_MtlGetUserDataVS_InPS(SRender_SimModelGetIDMtl())); } void SXMaterialEditor::FinalImageUncheckedMenu() diff --git a/source/sxmaterialeditor/common_callback.h b/source/sxmaterialeditor/common_callback.h index 4e4e976500c90fef6b276732ee4d806d3d09921b..d717cecdd797eb90f68d97c2f77a6ebcaf609ef3 100644 --- a/source/sxmaterialeditor/common_callback.h +++ b/source/sxmaterialeditor/common_callback.h @@ -5,7 +5,7 @@ #include #include -#include +#include #include #include diff --git a/source/sxmaterialeditor/edits_callback.cpp b/source/sxmaterialeditor/edits_callback.cpp index 22ad84b839569496fd90ab63fda36882867dc79f..4bc0a845d8f890bb45ea4e3cd1f60183faa6d447 100644 --- a/source/sxmaterialeditor/edits_callback.cpp +++ b/source/sxmaterialeditor/edits_callback.cpp @@ -41,14 +41,14 @@ LRESULT SXMaterialEditor_EditLigthColorR_Enter(HWND hwnd, UINT msg, WPARAM wPara SXMaterialEditor::pEditLigthColorR->getText(szStr, 32); - ID idGlobalLight = SML_LigthsGetGlobal(); + ID idGlobalLight = SLight_GetGlobal(); if (idGlobalLight > -1) { float3 vColor; - SML_LigthsGetColor(idGlobalLight, &vColor); + SLight_GetColor(idGlobalLight, &vColor); sscanf(szStr, "%f", &vColor.x); - SML_LigthsSetColor(idGlobalLight, &vColor); + SLight_SetColor(idGlobalLight, &vColor); SXMaterialEditor::pStaticLigthColor->setColorBrush(RGB(DWORD(vColor.x * 255.0), DWORD(vColor.y * 255.0), DWORD(vColor.z * 255.0))); } @@ -62,14 +62,14 @@ LRESULT SXMaterialEditor_EditLigthColorG_Enter(HWND hwnd, UINT msg, WPARAM wPara SXMaterialEditor::pEditLigthColorG->getText(szStr, 32); - ID idGlobalLight = SML_LigthsGetGlobal(); + ID idGlobalLight = SLight_GetGlobal(); if (idGlobalLight > -1) { float3 vColor; - SML_LigthsGetColor(idGlobalLight, &vColor); + SLight_GetColor(idGlobalLight, &vColor); sscanf(szStr, "%f", &vColor.y); - SML_LigthsSetColor(idGlobalLight, &vColor); + SLight_SetColor(idGlobalLight, &vColor); SXMaterialEditor::pStaticLigthColor->setColorBrush(RGB(DWORD(vColor.x * 255.0), DWORD(vColor.y * 255.0), DWORD(vColor.z * 255.0))); } @@ -83,14 +83,14 @@ LRESULT SXMaterialEditor_EditLigthColorB_Enter(HWND hwnd, UINT msg, WPARAM wPara SXMaterialEditor::pEditLigthColorB->getText(szStr, 32); - ID idGlobalLight = SML_LigthsGetGlobal(); + ID idGlobalLight = SLight_GetGlobal(); if (idGlobalLight > -1) { float3 vColor; - SML_LigthsGetColor(idGlobalLight, &vColor); + SLight_GetColor(idGlobalLight, &vColor); sscanf(szStr, "%f", &vColor.z); - SML_LigthsSetColor(idGlobalLight, &vColor); + SLight_SetColor(idGlobalLight, &vColor); SXMaterialEditor::pStaticLigthColor->setColorBrush(RGB(DWORD(vColor.x * 255.0), DWORD(vColor.y * 255.0), DWORD(vColor.z * 255.0))); } @@ -105,12 +105,12 @@ LRESULT SXMaterialEditor_EditTex_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARA SXMaterialEditor::pEditTex->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetTexture(SXMaterialEditor::idMat, szStr); + SMtrl_MtlSetTexture(SXMaterialEditor::idMat, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetTexture(SXMaterialEditor::idMat, szStr2); + SMtrl_MtlGetTexture(SXMaterialEditor::idMat, szStr2); TexProcInputString(szStr); SXMaterialEditor::pEditTex->setText(szStr); @@ -127,12 +127,12 @@ LRESULT SXMaterialEditor_EditVS_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditVS->getText(szStr, SXGC_SHADER_MAX_SIZE_DIRNAME); if (SGCore_ShaderFileExists(szStr)) - SML_MtlSetVS(SXMaterialEditor::idMat, szStr); + SMtrl_MtlSetVS(SXMaterialEditor::idMat, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetVS(SXMaterialEditor::idMat, szStr2); + SMtrl_MtlGetVS(SXMaterialEditor::idMat, szStr2); TexProcInputString(szStr); SXMaterialEditor::pEditVS->setText(szStr); @@ -149,12 +149,12 @@ LRESULT SXMaterialEditor_EditPS_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditPS->getText(szStr, SXGC_SHADER_MAX_SIZE_DIRNAME); if (SGCore_ShaderFileExists(szStr)) - SML_MtlSetPS(SXMaterialEditor::idMat, szStr); + SMtrl_MtlSetPS(SXMaterialEditor::idMat, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetPS(SXMaterialEditor::idMat, szStr2); + SMtrl_MtlGetPS(SXMaterialEditor::idMat, szStr2); TexProcInputString(szStr); SXMaterialEditor::pEditPS->setText(szStr); @@ -174,7 +174,7 @@ LRESULT SXMaterialEditor_EditHitChance_Enter(HWND hwnd, UINT msg, WPARAM wParam, sscanf(szStr, "%f", &fValue); SXMaterialEditor::pTrackBarHitChance->setPos(fValue * 100); - SML_MtlSetHitChance(SXMaterialEditor::idMat, fValue*0.01f); + SMtrl_MtlSetHitChance(SXMaterialEditor::idMat, fValue*0.01f); SXMaterialEditor::pEditHitChance->setText(String(fValue).c_str()); return 0; @@ -190,7 +190,7 @@ LRESULT SXMaterialEditor_EditDurability_Enter(HWND hwnd, UINT msg, WPARAM wParam sscanf(szStr, "%f", &fValue); - SML_MtlSetDurability(SXMaterialEditor::idMat, fValue); + SMtrl_MtlSetDurability(SXMaterialEditor::idMat, fValue); SXMaterialEditor::pEditDurability->setText(String(fValue).c_str()); return 0; @@ -206,7 +206,7 @@ LRESULT SXMaterialEditor_EditDensity_Enter(HWND hwnd, UINT msg, WPARAM wParam, L sscanf(szStr, "%f", &fValue); - SML_MtlSetDensity(SXMaterialEditor::idMat, fValue); + SMtrl_MtlSetDensity(SXMaterialEditor::idMat, fValue); SXMaterialEditor::pEditDensity->setText(String(fValue).c_str()); return 0; @@ -221,12 +221,12 @@ LRESULT SXMaterialEditor_EditTexLighting_Enter(HWND hwnd, UINT msg, WPARAM wPara SXMaterialEditor::pEditTexLighting->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetTextureLighting(SXMaterialEditor::idMat, szStr); + SMtrl_MtlSetTextureLighting(SXMaterialEditor::idMat, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetTextureLighting(SXMaterialEditor::idMat, szStr2); + SMtrl_MtlGetTextureLighting(SXMaterialEditor::idMat, szStr2); TexProcInputString(szStr); SXMaterialEditor::pEditTexLighting->setText(szStr); @@ -244,12 +244,12 @@ LRESULT SXMaterialEditor_EditMask_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPAR SXMaterialEditor::pEditMask->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetMaskTex(SXMaterialEditor::idMat, szStr); + SMtrl_MtlSetMaskTex(SXMaterialEditor::idMat, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetMaskTex(SXMaterialEditor::idMat, szStr2); + SMtrl_MtlGetMaskTex(SXMaterialEditor::idMat, szStr2); TexProcInputString(szStr); SXMaterialEditor::pEditMask->setText(szStr); @@ -266,12 +266,12 @@ LRESULT SXMaterialEditor_EditMR_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditMR->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetMRTex(SXMaterialEditor::idMat, 0, szStr); + SMtrl_MtlSetMRTex(SXMaterialEditor::idMat, 0, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetMRTex(SXMaterialEditor::idMat, 0, szStr2); + SMtrl_MtlGetMRTex(SXMaterialEditor::idMat, 0, szStr2); TexProcInputString(szStr); SXMaterialEditor::pEditMR->setText(szStr); @@ -288,12 +288,12 @@ LRESULT SXMaterialEditor_EditMG_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditMG->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetMRTex(SXMaterialEditor::idMat, 1, szStr); + SMtrl_MtlSetMRTex(SXMaterialEditor::idMat, 1, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetMRTex(SXMaterialEditor::idMat, 1, szStr2); + SMtrl_MtlGetMRTex(SXMaterialEditor::idMat, 1, szStr2); TexProcInputString(szStr); SXMaterialEditor::pEditMG->setText(szStr); @@ -310,12 +310,12 @@ LRESULT SXMaterialEditor_EditMB_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditMB->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetMRTex(SXMaterialEditor::idMat, 2, szStr); + SMtrl_MtlSetMRTex(SXMaterialEditor::idMat, 2, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetMRTex(SXMaterialEditor::idMat, 2, szStr2); + SMtrl_MtlGetMRTex(SXMaterialEditor::idMat, 2, szStr2); TexProcInputString(szStr); SXMaterialEditor::pEditMB->setText(szStr); @@ -332,12 +332,12 @@ LRESULT SXMaterialEditor_EditMA_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditMA->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetMRTex(SXMaterialEditor::idMat, 3, szStr); + SMtrl_MtlSetMRTex(SXMaterialEditor::idMat, 3, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetMRTex(SXMaterialEditor::idMat, 3, szStr); + SMtrl_MtlGetMRTex(SXMaterialEditor::idMat, 3, szStr); TexProcInputString(szStr); SXMaterialEditor::pEditMA->setText(szStr); @@ -355,12 +355,12 @@ LRESULT SXMaterialEditor_EditDR_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditDR->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetDTex(SXMaterialEditor::idMat, 0, szStr); + SMtrl_MtlSetDTex(SXMaterialEditor::idMat, 0, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetDTex(SXMaterialEditor::idMat, 0, szStr); + SMtrl_MtlGetDTex(SXMaterialEditor::idMat, 0, szStr); TexProcInputString(szStr); SXMaterialEditor::pEditDR->setText(szStr); @@ -377,12 +377,12 @@ LRESULT SXMaterialEditor_EditDG_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditDG->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetDTex(SXMaterialEditor::idMat, 1, szStr); + SMtrl_MtlSetDTex(SXMaterialEditor::idMat, 1, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetDTex(SXMaterialEditor::idMat, 1, szStr); + SMtrl_MtlGetDTex(SXMaterialEditor::idMat, 1, szStr); TexProcInputString(szStr); SXMaterialEditor::pEditDR->setText(szStr); @@ -399,12 +399,12 @@ LRESULT SXMaterialEditor_EditDB_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditDB->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetDTex(SXMaterialEditor::idMat, 2, szStr); + SMtrl_MtlSetDTex(SXMaterialEditor::idMat, 2, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetDTex(SXMaterialEditor::idMat, 2, szStr); + SMtrl_MtlGetDTex(SXMaterialEditor::idMat, 2, szStr); TexProcInputString(szStr); SXMaterialEditor::pEditDR->setText(szStr); @@ -421,12 +421,12 @@ LRESULT SXMaterialEditor_EditDA_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM SXMaterialEditor::pEditDA->getText(szStr, SXGC_LOADTEX_MAX_SIZE_DIRNAME); if (SGCore_LoadTexFileExists(szStr)) - SML_MtlSetDTex(SXMaterialEditor::idMat, 3, szStr); + SMtrl_MtlSetDTex(SXMaterialEditor::idMat, 3, szStr); else { char szStr2[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; szStr2[0] = 0; - SML_MtlGetDTex(SXMaterialEditor::idMat, 3, szStr); + SMtrl_MtlGetDTex(SXMaterialEditor::idMat, 3, szStr); TexProcInputString(szStr); SXMaterialEditor::pEditDR->setText(szStr); @@ -448,7 +448,7 @@ LRESULT SXMaterialEditor_EditRoughness_Enter(HWND hwnd, UINT msg, WPARAM wParam, sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarRoughness->setPos(tmpval*100); - SML_MtlSetRoughness(SXMaterialEditor::idMat, tmpval); + SMtrl_MtlSetRoughness(SXMaterialEditor::idMat, tmpval); return 0; } @@ -464,7 +464,7 @@ LRESULT SXMaterialEditor_EditF0_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPARAM sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarF0->setPos(tmpval * 100); - SML_MtlSetF0(SXMaterialEditor::idMat, tmpval); + SMtrl_MtlSetF0(SXMaterialEditor::idMat, tmpval); return 0; } @@ -479,7 +479,7 @@ LRESULT SXMaterialEditor_EditThickness_Enter(HWND hwnd, UINT msg, WPARAM wParam, sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarThickness->setPos(tmpval * 100); - SML_MtlSetThickness(SXMaterialEditor::idMat, tmpval); + SMtrl_MtlSetThickness(SXMaterialEditor::idMat, tmpval); return 0; } @@ -496,7 +496,7 @@ LRESULT SXMaterialEditor_EditUDVSX_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPA sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarUDVSX->setPos(tmpval * 100); - SML_MtlSetUserDataVS(SXMaterialEditor::idMat, 0, tmpval); + SMtrl_MtlSetUserDataVS(SXMaterialEditor::idMat, 0, tmpval); return 0; } @@ -511,7 +511,7 @@ LRESULT SXMaterialEditor_EditUDVSY_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPA sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarUDVSY->setPos(tmpval * 100); - SML_MtlSetUserDataVS(SXMaterialEditor::idMat, 1, tmpval); + SMtrl_MtlSetUserDataVS(SXMaterialEditor::idMat, 1, tmpval); return 0; } @@ -526,7 +526,7 @@ LRESULT SXMaterialEditor_EditUDVSZ_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPA sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarUDVSZ->setPos(tmpval * 100); - SML_MtlSetUserDataVS(SXMaterialEditor::idMat, 2, tmpval); + SMtrl_MtlSetUserDataVS(SXMaterialEditor::idMat, 2, tmpval); return 0; } @@ -541,7 +541,7 @@ LRESULT SXMaterialEditor_EditUDVSW_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPA sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarUDVSW->setPos(tmpval * 100); - SML_MtlSetUserDataVS(SXMaterialEditor::idMat, 3, tmpval); + SMtrl_MtlSetUserDataVS(SXMaterialEditor::idMat, 3, tmpval); return 0; } @@ -557,7 +557,7 @@ LRESULT SXMaterialEditor_EditUDPSX_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPA sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarUDPSX->setPos(tmpval * 100); - SML_MtlSetUserDataPS(SXMaterialEditor::idMat, 0, tmpval); + SMtrl_MtlSetUserDataPS(SXMaterialEditor::idMat, 0, tmpval); return 0; } @@ -572,7 +572,7 @@ LRESULT SXMaterialEditor_EditUDPSY_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPA sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarUDPSY->setPos(tmpval * 100); - SML_MtlSetUserDataPS(SXMaterialEditor::idMat, 1, tmpval); + SMtrl_MtlSetUserDataPS(SXMaterialEditor::idMat, 1, tmpval); return 0; } @@ -587,7 +587,7 @@ LRESULT SXMaterialEditor_EditUDPSZ_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPA sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarUDPSZ->setPos(tmpval * 100); - SML_MtlSetUserDataPS(SXMaterialEditor::idMat, 2, tmpval); + SMtrl_MtlSetUserDataPS(SXMaterialEditor::idMat, 2, tmpval); return 0; } @@ -602,6 +602,6 @@ LRESULT SXMaterialEditor_EditUDPSW_Enter(HWND hwnd, UINT msg, WPARAM wParam, LPA sscanf(szStr, "%f", &tmpval); SXMaterialEditor::pTrackBarUDPSW->setPos(tmpval * 100); - SML_MtlSetUserDataPS(SXMaterialEditor::idMat, 3, tmpval); + SMtrl_MtlSetUserDataPS(SXMaterialEditor::idMat, 3, tmpval); return 0; } \ No newline at end of file diff --git a/source/sxmaterialeditor/edits_callback.h b/source/sxmaterialeditor/edits_callback.h index 684989ad488b1bbf5f298aecea94fe8666770de1..3c3b6384ca8eaba45c01bccb549d97ea7fb93129 100644 --- a/source/sxmaterialeditor/edits_callback.h +++ b/source/sxmaterialeditor/edits_callback.h @@ -5,7 +5,7 @@ #include #include -#include +#include #include #include diff --git a/source/sxmaterialeditor/material_editor.cpp b/source/sxmaterialeditor/material_editor.cpp index 768061724c78f4133c650ec586caef111d6c8341..744c3c5f24f6e89b44bfd01bab8a203031a8eeb8 100644 --- a/source/sxmaterialeditor/material_editor.cpp +++ b/source/sxmaterialeditor/material_editor.cpp @@ -1430,8 +1430,8 @@ void SXMaterialEditor::MaterialEditorUpdate(DWORD timeDelta) char vs[1024]; char ps[1024]; - SML_MtlGetVS(SXMaterialEditor::idMat, vs); - SML_MtlGetPS(SXMaterialEditor::idMat, ps); + SMtrl_MtlGetVS(SXMaterialEditor::idMat, vs); + SMtrl_MtlGetPS(SXMaterialEditor::idMat, ps); if ((skit = SXMaterialEditor::pShaders->find(vs, ps)) >= 0) SXMaterialEditor::pComboBoxShaders->setSel(skit + 1); @@ -1441,9 +1441,9 @@ void SXMaterialEditor::MaterialEditorUpdate(DWORD timeDelta) if (!SXMaterialEditor::pComboBoxParamL->getFocus()) { - float thikcness = SML_MtlGetThickness(SXMaterialEditor::idMat); - float roughness = SML_MtlGetRoughness(SXMaterialEditor::idMat); - float f0 = SML_MtlGetF0(SXMaterialEditor::idMat); + float thikcness = SMtrl_MtlGetThickness(SXMaterialEditor::idMat); + float roughness = SMtrl_MtlGetRoughness(SXMaterialEditor::idMat); + float f0 = SMtrl_MtlGetF0(SXMaterialEditor::idMat); skit = -1; if ((skit = SXMaterialEditor::pParamL->find(thikcness, roughness, f0)) >= 0) diff --git a/source/sxmaterialeditor/material_editor.h b/source/sxmaterialeditor/material_editor.h index 5667deaa17bfb30ad36935efc165e035baacdf7e..21574e8183dcd00b5204d90ec6a1a2827f58bf45 100644 --- a/source/sxmaterialeditor/material_editor.h +++ b/source/sxmaterialeditor/material_editor.h @@ -8,7 +8,7 @@ #include #include -#include +#include #include #include diff --git a/source/sxmaterialeditor/sxmaterialeditor.cpp b/source/sxmaterialeditor/sxmaterialeditor.cpp index 9dbcd70f6b5ff45ad1da8836babb416749eb65c4..3d14901a3470b391ceb7096627855abdab89d180 100644 --- a/source/sxmaterialeditor/sxmaterialeditor.cpp +++ b/source/sxmaterialeditor/sxmaterialeditor.cpp @@ -477,14 +477,14 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLin SRender_SimModelAdd("cube.dse"); SRender_SimModelAdd("plane.dse"); - SML_LigthsCreatePoint( + SLight_CreatePoint( &float3(110,110,-110), LIGHTS_GLOBAL_STD_RADIUS, &float3(1,1,1), true, true); - SML_LigthsSetEnable(SML_LigthsGetCount() - 1, true); - SML_LigthsSetName(SML_LigthsGetCount() - 1, "sun"); + SLight_SetEnable(SLight_GetCount() - 1, true); + SLight_SetName(SLight_GetCount() - 1, "sun"); SXMaterialEditor::pEditLigthColorR->setText("1"); SXMaterialEditor::pEditLigthColorG->setText("1"); diff --git a/source/sxmaterialeditor/trackbars_callback.cpp b/source/sxmaterialeditor/trackbars_callback.cpp index 4a1ff70b91a371612862533619b4ac1079ea1cae..2c53d79c8d65a517af06877f6d685407dc9b875f 100644 --- a/source/sxmaterialeditor/trackbars_callback.cpp +++ b/source/sxmaterialeditor/trackbars_callback.cpp @@ -10,7 +10,7 @@ LRESULT SXMaterialEditor_TrackBarHitChance_MouseMove(HWND hwnd, UINT msg, WPARAM sprintf(thickness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditHitChance->setText(thickness); - SML_MtlSetHitChance(SXMaterialEditor::idMat, float(pos)*0.01f); + SMtrl_MtlSetHitChance(SXMaterialEditor::idMat, float(pos)*0.01f); return 0; } @@ -24,7 +24,7 @@ LRESULT SXMaterialEditor_TrackBarRoughness_MouseMove(HWND hwnd, UINT msg, WPARAM sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditRoughness->setText(roughness); - SML_MtlSetRoughness(SXMaterialEditor::idMat, float(pos)*0.01f); + SMtrl_MtlSetRoughness(SXMaterialEditor::idMat, float(pos)*0.01f); return 0; } @@ -38,7 +38,7 @@ LRESULT SXMaterialEditor_TrackBarThickness_MouseMove(HWND hwnd, UINT msg, WPARAM sprintf(thickness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditThickness->setText(thickness); - SML_MtlSetThickness(SXMaterialEditor::idMat, float(pos)*0.01f); + SMtrl_MtlSetThickness(SXMaterialEditor::idMat, float(pos)*0.01f); return 0; } @@ -52,7 +52,7 @@ LRESULT SXMaterialEditor_TrackBarF0_MouseMove(HWND hwnd, UINT msg, WPARAM wParam sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditF0->setText(roughness); - SML_MtlSetF0(SXMaterialEditor::idMat, float(pos)*0.01f); + SMtrl_MtlSetF0(SXMaterialEditor::idMat, float(pos)*0.01f); return 0; } @@ -68,7 +68,7 @@ LRESULT SXMaterialEditor_TrackBarUDVSX_MouseMove(HWND hwnd, UINT msg, WPARAM wPa sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditUDVSX->setText(roughness); - SML_MtlSetUserDataVS(SXMaterialEditor::idMat, 0, float(pos)*0.01f); + SMtrl_MtlSetUserDataVS(SXMaterialEditor::idMat, 0, float(pos)*0.01f); return 0; } @@ -82,7 +82,7 @@ LRESULT SXMaterialEditor_TrackBarUDVSY_MouseMove(HWND hwnd, UINT msg, WPARAM wPa sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditUDVSY->setText(roughness); - SML_MtlSetUserDataVS(SXMaterialEditor::idMat, 1, float(pos)*0.01f); + SMtrl_MtlSetUserDataVS(SXMaterialEditor::idMat, 1, float(pos)*0.01f); return 0; } @@ -96,7 +96,7 @@ LRESULT SXMaterialEditor_TrackBarUDVSZ_MouseMove(HWND hwnd, UINT msg, WPARAM wPa sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditUDVSZ->setText(roughness); - SML_MtlSetUserDataVS(SXMaterialEditor::idMat, 2, float(pos)*0.01f); + SMtrl_MtlSetUserDataVS(SXMaterialEditor::idMat, 2, float(pos)*0.01f); return 0; } @@ -110,7 +110,7 @@ LRESULT SXMaterialEditor_TrackBarUDVSW_MouseMove(HWND hwnd, UINT msg, WPARAM wPa sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditUDVSW->setText(roughness); - SML_MtlSetUserDataVS(SXMaterialEditor::idMat, 3, float(pos)*0.01f); + SMtrl_MtlSetUserDataVS(SXMaterialEditor::idMat, 3, float(pos)*0.01f); return 0; } @@ -126,7 +126,7 @@ LRESULT SXMaterialEditor_TrackBarUDPSX_MouseMove(HWND hwnd, UINT msg, WPARAM wPa sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditUDPSX->setText(roughness); - SML_MtlSetUserDataPS(SXMaterialEditor::idMat, 0, float(pos)*0.01f); + SMtrl_MtlSetUserDataPS(SXMaterialEditor::idMat, 0, float(pos)*0.01f); return 0; } @@ -140,7 +140,7 @@ LRESULT SXMaterialEditor_TrackBarUDPSY_MouseMove(HWND hwnd, UINT msg, WPARAM wPa sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditUDPSY->setText(roughness); - SML_MtlSetUserDataPS(SXMaterialEditor::idMat, 1, float(pos)*0.01f); + SMtrl_MtlSetUserDataPS(SXMaterialEditor::idMat, 1, float(pos)*0.01f); return 0; } @@ -154,7 +154,7 @@ LRESULT SXMaterialEditor_TrackBarUDPSZ_MouseMove(HWND hwnd, UINT msg, WPARAM wPa sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditUDPSZ->setText(roughness); - SML_MtlSetUserDataPS(SXMaterialEditor::idMat, 2, float(pos)*0.01f); + SMtrl_MtlSetUserDataPS(SXMaterialEditor::idMat, 2, float(pos)*0.01f); return 0; } @@ -168,7 +168,7 @@ LRESULT SXMaterialEditor_TrackBarUDPSW_MouseMove(HWND hwnd, UINT msg, WPARAM wPa sprintf(roughness, "%.2f", float(pos)*0.01f); SXMaterialEditor::pEditUDPSW->setText(roughness); - SML_MtlSetUserDataPS(SXMaterialEditor::idMat, 3, float(pos)*0.01f); + SMtrl_MtlSetUserDataPS(SXMaterialEditor::idMat, 3, float(pos)*0.01f); return 0; } \ No newline at end of file diff --git a/source/sxmaterialeditor/trackbars_callback.h b/source/sxmaterialeditor/trackbars_callback.h index 79ee150fa8a9be24ae69819fc187b106e14239c6..07393a1a83b0ba444754380e7a6613e9b10c59b6 100644 --- a/source/sxmaterialeditor/trackbars_callback.h +++ b/source/sxmaterialeditor/trackbars_callback.h @@ -5,7 +5,7 @@ #include #include -#include +#include #include #include