384 lines
11 KiB
C++
384 lines
11 KiB
C++
// Copyright (C) 2002-2006 Nikolaus Gebhardt
|
|
// This file is part of the "Irrlicht Engine".
|
|
// For conditions of distribution and use, see copyright notice in irrlicht.h
|
|
|
|
#include "IVideoDriver.h"
|
|
#include "NativeConverter.h"
|
|
|
|
namespace Irrlicht
|
|
{
|
|
namespace Video
|
|
{
|
|
IVideoDriver::IVideoDriver(irr::video::IVideoDriver* driver)
|
|
: Driver(driver), Services(0)
|
|
{
|
|
if (Driver && Driver->getGPUProgrammingServices())
|
|
{
|
|
Services = new Irrlicht::Video::IGPUProgrammingServices(
|
|
Driver->getGPUProgrammingServices(),
|
|
this );
|
|
}
|
|
}
|
|
|
|
bool IVideoDriver::BeginScene(bool backBuffer, bool zBuffer, Color color)
|
|
{
|
|
return Driver->beginScene(backBuffer, zBuffer, (irr::s32)color.color);
|
|
}
|
|
|
|
bool IVideoDriver::EndScene()
|
|
{
|
|
return Driver->endScene();
|
|
}
|
|
|
|
bool IVideoDriver::EndScene( System::IntPtr ptr )
|
|
{
|
|
return Driver->endScene( reinterpret_cast<irr::s32>((void*)ptr) );
|
|
}
|
|
|
|
bool IVideoDriver::EndScene( System::IntPtr ptr, Core::Rect sourceRect )
|
|
{
|
|
irr::core::rect<irr::s32> rct = irr::NativeConverter::getNativeRect( sourceRect );
|
|
|
|
return Driver->endScene( reinterpret_cast<irr::s32>((void*)ptr), &rct );
|
|
}
|
|
|
|
bool IVideoDriver::QueryFeature(VideoDriverFeature feature)
|
|
{
|
|
return Driver->queryFeature((irr::video::E_VIDEO_DRIVER_FEATURE)feature);
|
|
}
|
|
|
|
void IVideoDriver::SetTransform(TransformationState state, Core::Matrix4 mat)
|
|
{
|
|
irr::core::matrix4 imat;
|
|
for (int i=0; i<16; ++i)
|
|
imat[i] = mat.Members[i];
|
|
|
|
Driver->setTransform((irr::video::E_TRANSFORMATION_STATE)state, imat);
|
|
}
|
|
|
|
Core::Matrix4 IVideoDriver::GetTransform( TransformationState state )
|
|
{
|
|
Core::Matrix4 mat;
|
|
|
|
irr::core::matrix4 imat = Driver->getTransform((irr::video::E_TRANSFORMATION_STATE)state );
|
|
|
|
for (int i=0; i<16; ++i)
|
|
mat.Members[i] = imat[i];
|
|
|
|
return mat;
|
|
}
|
|
|
|
|
|
ITexture* IVideoDriver::GetTexture(System::String* filename)
|
|
{
|
|
ITexture* ret = 0;
|
|
char* str = (char*)(void*)
|
|
System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(filename);
|
|
|
|
irr::video::ITexture* tex = Driver->getTexture(str);
|
|
if (tex)
|
|
ret = new ITexture(tex);
|
|
|
|
System::Runtime::InteropServices::Marshal::FreeHGlobal(str);
|
|
return ret;
|
|
}
|
|
|
|
ITexture* IVideoDriver::AddTexture(Core::Dimension2D size, System::String* name,
|
|
ColorFormat format)
|
|
{
|
|
char* str = (char*)(void*)
|
|
System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(name);
|
|
|
|
irr::video::ITexture* tex =
|
|
Driver->addTexture(irr::core::dimension2d<irr::s32>(size.Width, size.Height),
|
|
str, (irr::video::ECOLOR_FORMAT)format);
|
|
|
|
System::Runtime::InteropServices::Marshal::FreeHGlobal(str);
|
|
return tex ? new ITexture(tex) : 0;
|
|
}
|
|
|
|
ITexture* IVideoDriver::AddTexture(Core::Dimension2D size, System::String* name)
|
|
{
|
|
return AddTexture(size, name, ColorFormat::A1R5G5B5);
|
|
}
|
|
|
|
void IVideoDriver::SetMaterial(Material material)
|
|
{
|
|
Driver->setMaterial(irr::NativeConverter::getNativeMaterial(material));
|
|
}
|
|
|
|
void IVideoDriver::RemoveTexture(ITexture* texture)
|
|
{
|
|
if (!texture)
|
|
return;
|
|
|
|
Driver->removeTexture(texture->get_NativeTexture());
|
|
}
|
|
|
|
void IVideoDriver::RemoveAllTextures()
|
|
{
|
|
Driver->removeAllTextures();
|
|
}
|
|
|
|
void IVideoDriver::MakeColorKeyTexture(ITexture* texture, Color color)
|
|
{
|
|
if (texture)
|
|
Driver->makeColorKeyTexture(texture->get_NativeTexture(), color.color);
|
|
}
|
|
|
|
void IVideoDriver::MakeColorKeyTexture(ITexture* texture, Core::Position2D colorKeyPixelPos)
|
|
{
|
|
if (texture)
|
|
Driver->makeColorKeyTexture(texture->get_NativeTexture(),
|
|
irr::core::position2d<irr::s32>(colorKeyPixelPos.X, colorKeyPixelPos.Y));
|
|
}
|
|
|
|
void IVideoDriver::SetRenderTarget(ITexture* texture)
|
|
{
|
|
if (texture)
|
|
Driver->setRenderTarget(texture->get_NativeTexture());
|
|
}
|
|
|
|
void IVideoDriver::set_ViewPort(Core::Rect area)
|
|
{
|
|
Driver->setViewPort(irr::core::rect<irr::s32>(area.UpperLeftCorner.X, area.UpperLeftCorner.Y,
|
|
area.LowerRightCorner.X, area.LowerRightCorner.Y));
|
|
}
|
|
|
|
Core::Rect IVideoDriver::get_ViewPort()
|
|
{
|
|
irr::core::rect<irr::s32> r = Driver->getViewPort();
|
|
return Core::Rect(r.UpperLeftCorner.X, r.UpperLeftCorner.Y,
|
|
r.LowerRightCorner.X, r.LowerRightCorner.Y);
|
|
}
|
|
|
|
void IVideoDriver::DrawIndexedTriangleList(Vertex3D vertices[],
|
|
int vertexCount, unsigned short indexList __gc[], int triangleCount)
|
|
{
|
|
Vertex3D __pin * pVertices = &vertices[0];
|
|
unsigned short __pin * pIndices = &indexList[0];
|
|
|
|
Driver->drawIndexedTriangleList((irr::video::S3DVertex*)((void*)pVertices),
|
|
vertexCount,
|
|
(unsigned short*)((void*)pIndices),
|
|
triangleCount);
|
|
}
|
|
|
|
void IVideoDriver::DrawIndexedTriangleList(Vertex3D2Tex vertices[],
|
|
int vertexCount, unsigned short indexList __gc[], int triangleCount)
|
|
{
|
|
Vertex3D2Tex __pin * pVertices = &vertices[0];
|
|
unsigned short __pin * pIndices = &indexList[0];
|
|
|
|
Driver->drawIndexedTriangleList((irr::video::S3DVertex2TCoords*)((void*)pVertices),
|
|
vertexCount,
|
|
(unsigned short*)((void*)pIndices),
|
|
triangleCount);
|
|
}
|
|
|
|
void IVideoDriver::DrawIndexedTriangleFan(Vertex3D vertices[],
|
|
int vertexCount, unsigned short indexList __gc[], int triangleCount)
|
|
{
|
|
Vertex3D __pin * pVertices = &vertices[0];
|
|
unsigned short __pin * pIndices = &indexList[0];
|
|
|
|
Driver->drawIndexedTriangleFan((irr::video::S3DVertex*)((void*)pVertices),
|
|
vertexCount,
|
|
(unsigned short*)((void*)pIndices),
|
|
triangleCount);
|
|
}
|
|
|
|
void IVideoDriver::DrawIndexedTriangleFan(Vertex3D2Tex vertices[],
|
|
int vertexCount, unsigned short indexList __gc[], int triangleCount)
|
|
{
|
|
Vertex3D2Tex __pin * pVertices = &vertices[0];
|
|
unsigned short __pin * pIndices = &indexList[0];
|
|
|
|
Driver->drawIndexedTriangleFan((irr::video::S3DVertex2TCoords*)((void*)pVertices),
|
|
vertexCount,
|
|
(unsigned short*)((void*)pIndices),
|
|
triangleCount);
|
|
}
|
|
|
|
void IVideoDriver::Draw3DLine(Core::Vector3D start, Core::Vector3D end,
|
|
Color color)
|
|
{
|
|
Driver->draw3DLine(irr::core::vector3df(start.X, start.Y, start.Z),
|
|
irr::core::vector3df(end.X, end.Y, end.Z), color.color);
|
|
}
|
|
|
|
int IVideoDriver::get_PrimitiveCountDrawn()
|
|
{
|
|
return Driver->getPrimitiveCountDrawn();
|
|
}
|
|
|
|
int IVideoDriver::get_FPS()
|
|
{
|
|
return Driver->getFPS();
|
|
}
|
|
|
|
void IVideoDriver::Draw2DImage(ITexture* texture, Core::Position2D pos)
|
|
{
|
|
if (!texture)
|
|
return;
|
|
|
|
Driver->draw2DImage(texture->get_NativeTexture(),
|
|
irr::core::position2d<irr::s32>(pos.X, pos.Y));
|
|
}
|
|
|
|
void IVideoDriver::Draw3DTriangle(Core::Triangle3D triangle, Color color)
|
|
{
|
|
irr::core::triangle3d<irr::f32> tri;
|
|
tri.set(
|
|
irr::core::vector3df(triangle.pointA.X, triangle.pointA.Y, triangle.pointA.Z),
|
|
irr::core::vector3df(triangle.pointB.X, triangle.pointB.Y, triangle.pointB.Z),
|
|
irr::core::vector3df(triangle.pointC.X, triangle.pointC.Y, triangle.pointC.Z));
|
|
|
|
Driver->draw3DTriangle(tri, color.color);
|
|
}
|
|
|
|
void IVideoDriver::Draw3DBox(Core::Box3D box, Color color)
|
|
{
|
|
Driver->draw3DBox( irr::NativeConverter::getNativeBox(box),
|
|
irr::NativeConverter::getNativeColor(color));
|
|
}
|
|
|
|
|
|
void IVideoDriver::Draw2DImage(ITexture* texture, Core::Position2D destPos,
|
|
Core::Rect sourceRect, Core::Rect clipRect,
|
|
Color color, bool useAlphaChannelOfTexture)
|
|
{
|
|
if (!texture)
|
|
return;
|
|
|
|
irr::core::rect<irr::s32> clip = irr::NativeConverter::getNativeRect(clipRect);
|
|
|
|
Driver->draw2DImage(texture->get_NativeTexture(),
|
|
irr::NativeConverter::getNativePos(destPos),
|
|
irr::NativeConverter::getNativeRect(sourceRect),
|
|
&clip,
|
|
color.color, useAlphaChannelOfTexture);
|
|
}
|
|
|
|
void IVideoDriver::Draw2DImage(ITexture* texture, Core::Position2D destPos,
|
|
Core::Rect sourceRect, Color color, bool useAlphaChannelOfTexture)
|
|
{
|
|
if (!texture)
|
|
return;
|
|
|
|
Driver->draw2DImage(texture->get_NativeTexture(),
|
|
irr::NativeConverter::getNativePos(destPos),
|
|
irr::NativeConverter::getNativeRect(sourceRect),
|
|
0, color.color, useAlphaChannelOfTexture);
|
|
}
|
|
|
|
void IVideoDriver::Draw2DRectangle(Color color, Core::Rect pos, Core::Rect clipp)
|
|
{
|
|
irr::core::rect<irr::s32> clip = irr::NativeConverter::getNativeRect(clipp);
|
|
Driver->draw2DRectangle(color.color,
|
|
irr::NativeConverter::getNativeRect(pos), &clip);
|
|
}
|
|
|
|
void IVideoDriver::Draw2DRectangle(Color color, Core::Rect pos)
|
|
{
|
|
Driver->draw2DRectangle(color.color,
|
|
irr::NativeConverter::getNativeRect(pos), 0);
|
|
}
|
|
|
|
void IVideoDriver::Draw2DLine(Core::Position2D start, Core::Position2D end, Color color)
|
|
{
|
|
Driver->draw2DLine(
|
|
irr::NativeConverter::getNativePos(start),
|
|
irr::NativeConverter::getNativePos(end),
|
|
color.color);
|
|
}
|
|
|
|
void IVideoDriver::DrawStencilShadowVolume(Core::Vector3D triangles[], int count, bool zfail)
|
|
{
|
|
Core::Vector3D __pin * v = &triangles[0];
|
|
Driver->drawStencilShadowVolume((irr::core::vector3df*)((void*)v), count, zfail);
|
|
}
|
|
|
|
void IVideoDriver::DrawStencilShadow(bool clearStencilBuffer,
|
|
Color leftUpEdge, Color rightUpEdge, Color leftDownEdge, Color rightDownEdge)
|
|
{
|
|
Driver->drawStencilShadow(clearStencilBuffer,
|
|
leftUpEdge.color, rightUpEdge.color, leftDownEdge.color, rightDownEdge.color);
|
|
}
|
|
|
|
void IVideoDriver::SetFog(Color color, bool linearFog, float start, float end,
|
|
float density, bool pixelFog, bool rangeFog)
|
|
{
|
|
Driver->setFog(color.color, linearFog, start, end, density, pixelFog, rangeFog);
|
|
}
|
|
|
|
Core::Dimension2D IVideoDriver::get_ScreenSize()
|
|
{
|
|
irr::core::dimension2d<irr::s32> dim = Driver->getScreenSize();
|
|
return Core::Dimension2D(dim.Width, dim.Height);
|
|
}
|
|
|
|
void IVideoDriver::DeleteAllDynamicLights()
|
|
{
|
|
Driver->deleteAllDynamicLights();
|
|
}
|
|
|
|
void IVideoDriver::AddDynamicLight(Light light)
|
|
{
|
|
Driver->addDynamicLight(irr::NativeConverter::getNativeLight(light));
|
|
}
|
|
|
|
void IVideoDriver::SetAmbientLight(Colorf color)
|
|
{
|
|
Driver->setAmbientLight(irr::NativeConverter::getNativeColorf(color));
|
|
}
|
|
|
|
int IVideoDriver::get_MaximalDynamicLightAmount()
|
|
{
|
|
return Driver->getMaximalDynamicLightAmount();
|
|
}
|
|
|
|
int IVideoDriver::get_DynamicLightCount()
|
|
{
|
|
return Driver->getDynamicLightCount();
|
|
}
|
|
|
|
Light IVideoDriver::GetDynamicLight(int idx)
|
|
{
|
|
return irr::NativeConverter::getNETLight(
|
|
Driver->getDynamicLight(idx));
|
|
}
|
|
|
|
System::String* IVideoDriver::get_Name()
|
|
{
|
|
return new System::String(Driver->getName());
|
|
}
|
|
|
|
int IVideoDriver::get_MaximalPrimitiveCount()
|
|
{
|
|
return Driver->getMaximalPrimitiveCount();
|
|
}
|
|
|
|
void IVideoDriver::SetTextureCreationFlag(TextureCreationFlag flag, bool enabled)
|
|
{
|
|
Driver->setTextureCreationFlag((irr::video::E_TEXTURE_CREATION_FLAG)flag, enabled);
|
|
}
|
|
|
|
bool IVideoDriver::GetTextureCreationFlag(TextureCreationFlag flag)
|
|
{
|
|
return Driver->getTextureCreationFlag((irr::video::E_TEXTURE_CREATION_FLAG)flag);
|
|
}
|
|
|
|
IGPUProgrammingServices* IVideoDriver::get_GPUProgrammingServices()
|
|
{
|
|
return Services;
|
|
}
|
|
|
|
DriverType IVideoDriver::get_DriverType()
|
|
{
|
|
return (Irrlicht::Video::DriverType)Driver->getDriverType();
|
|
}
|
|
|
|
}
|
|
}
|