ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

d3dx9: Implement the D3DXVec*Array functions.

This commit is contained in:
Philip Nilsson 2008-03-21 00:33:45 +01:00 committed by Alexandre Julliard
parent c0b3af34b9
commit 0457333f55
4 changed files with 215 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
dlls/d3dx9_36/Makefile.in
View File

@ -8,7 +8,8 @@ IMPORTS = d3d9 d3dx8 kernel32
C_SRCS = \
d3dx9_36_main.c \
font.c
font.c \
math.c
@MAKE_DLL_RULES@

18
dlls/d3dx9_36/d3dx9_36.spec
View File

@ -307,30 +307,30 @@
@ stdcall D3DXVec2Hermite(ptr ptr ptr ptr ptr long) d3dx8.D3DXVec2Hermite
@ stdcall D3DXVec2Normalize(ptr ptr) d3dx8.D3DXVec2Normalize
@ stdcall D3DXVec2Transform(ptr ptr ptr) d3dx8.D3DXVec2Transform
@ stub D3DXVec2TransformArray
@ stdcall D3DXVec2TransformArray(ptr long ptr long ptr long)
@ stdcall D3DXVec2TransformCoord(ptr ptr ptr) d3dx8.D3DXVec2TransformCoord
@ stub D3DXVec2TransformCoordArray
@ stdcall D3DXVec2TransformCoordArray(ptr long ptr long ptr long)
@ stdcall D3DXVec2TransformNormal(ptr ptr ptr) d3dx8.D3DXVec2TransformNormal
@ stub D3DXVec2TransformNormalArray
@ stdcall D3DXVec2TransformNormalArray(ptr long ptr long ptr long)
@ stdcall D3DXVec3BaryCentric(ptr ptr ptr ptr long long) d3dx8.D3DXVec3BaryCentric
@ stdcall D3DXVec3CatmullRom(ptr ptr ptr ptr ptr long) d3dx8.D3DXVec3CatmullRom
@ stdcall D3DXVec3Hermite(ptr ptr ptr ptr ptr long) d3dx8.D3DXVec3Hermite
@ stdcall D3DXVec3Normalize(ptr ptr) d3dx8.D3DXVec3Normalize
@ stdcall D3DXVec3Project(ptr ptr ptr ptr ptr ptr) d3dx8.D3DXVec3Project
@ stub D3DXVec3ProjectArray
@ stdcall D3DXVec3ProjectArray(ptr long ptr long ptr ptr ptr ptr long)
@ stdcall D3DXVec3Transform(ptr ptr ptr) d3dx8.D3DXVec3Transform
@ stub D3DXVec3TransformArray
@ stdcall D3DXVec3TransformArray(ptr long ptr long ptr long)
@ stdcall D3DXVec3TransformCoord(ptr ptr ptr) d3dx8.D3DXVec3TransformCoord
@ stub D3DXVec3TransformCoordArray
@ stdcall D3DXVec3TransformCoordArray(ptr long ptr long ptr long)
@ stdcall D3DXVec3TransformNormal(ptr ptr ptr) d3dx8.D3DXVec3TransformNormal
@ stub D3DXVec3TransformNormalArray
@ stdcall D3DXVec3TransformNormalArray(ptr long ptr long ptr long)
@ stdcall D3DXVec3Unproject(ptr ptr ptr ptr ptr ptr) d3dx8.D3DXVec3Unproject
@ stub D3DXVec3UnprojectArray
@ stdcall D3DXVec3UnprojectArray(ptr long ptr long ptr ptr ptr ptr long)
@ stdcall D3DXVec4BaryCentric(ptr ptr ptr ptr long long) d3dx8.D3DXVec4BaryCentric
@ stdcall D3DXVec4CatmullRom(ptr ptr ptr ptr ptr long) d3dx8.D3DXVec4CatmullRom
@ stdcall D3DXVec4Cross(ptr ptr ptr ptr) d3dx8.D3DXVec4Cross
@ stdcall D3DXVec4Hermite(ptr ptr ptr ptr ptr long) d3dx8.D3DXVec4Hermite
@ stdcall D3DXVec4Normalize(ptr ptr) d3dx8.D3DXVec4Normalize
@ stdcall D3DXVec4Transform(ptr ptr ptr) d3dx8.D3DXVec4Transform
@ stub D3DXVec4TransformArray
@ stdcall D3DXVec4TransformArray(ptr long ptr long ptr long)
@ stub D3DXWeldVertices

195
dlls/d3dx9_36/math.c Normal file
View File

@ -0,0 +1,195 @@
/*
* Mathematical operations specific to D3DX9.
*
* Copyright (C) 2008 Philip Nilsson
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include "windef.h"
#include "wingdi.h"
#include "wine/debug.h"
#include "d3dx9.h"
WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
/*************************************************************************
* D3DXVec2TransformArray
*
* Transform an array of vectors by a matrix.
*/
D3DXVECTOR4* WINAPI D3DXVec2TransformArray(
D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride,
CONST D3DXMATRIX* matrix, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec2Transform(
(D3DXVECTOR4*)((char*)out + outstride * i),
(CONST D3DXVECTOR2*)((const char*)in + instride * i),
matrix);
}
return out;
}
/*************************************************************************
* D3DXVec2TransformCoordArray
*/
D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray(
D3DXVECTOR2* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride,
CONST D3DXMATRIX* matrix, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec2TransformCoord(
(D3DXVECTOR2*)((char*)out + outstride * i),
(CONST D3DXVECTOR2*)((const char*)in + instride * i),
matrix);
}
return out;
}
/*************************************************************************
* D3DXVec2TransformNormalArray
*/
D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray(
D3DXVECTOR2* out, UINT outstride, CONST D3DXVECTOR2 *in, UINT instride,
CONST D3DXMATRIX *matrix, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec2TransformNormal(
(D3DXVECTOR2*)((char*)out + outstride * i),
(CONST D3DXVECTOR2*)((const char*)in + instride * i),
matrix);
}
return out;
}
/*************************************************************************
* D3DXVec3ProjectArray
*
* Projects an array of vectors to the screen.
*/
D3DXVECTOR3* WINAPI D3DXVec3ProjectArray(
D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
CONST D3DVIEWPORT9* viewport, CONST D3DXMATRIX* projection,
CONST D3DXMATRIX* view, CONST D3DXMATRIX* world, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec3Project(
(D3DXVECTOR3*)((char*)out + outstride * i),
(CONST D3DXVECTOR3*)((const char*)in + instride * i),
viewport, projection, view, world);
}
return out;
}
/*************************************************************************
* D3DXVec3TransformArray
*/
D3DXVECTOR4* WINAPI D3DXVec3TransformArray(
D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
CONST D3DXMATRIX* matrix, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec3Transform(
(D3DXVECTOR4*)((char*)out + outstride * i),
(CONST D3DXVECTOR3*)((const char*)in + instride * i),
matrix);
}
return out;
}
/*************************************************************************
* D3DXVec3TransformCoordArray
*/
D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray(
D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
CONST D3DXMATRIX* matrix, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec3TransformCoord(
(D3DXVECTOR3*)((char*)out + outstride * i),
(CONST D3DXVECTOR3*)((const char*)in + instride * i),
matrix);
}
return out;
}
/*************************************************************************
* D3DXVec3TransformNormalArray
*/
D3DXVECTOR3* WINAPI D3DXVec3TransformNormalArray(
D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
CONST D3DXMATRIX* matrix, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec3TransformNormal(
(D3DXVECTOR3*)((char*)out + outstride * i),
(CONST D3DXVECTOR3*)((const char*)in + instride * i),
matrix);
}
return out;
}
/*************************************************************************
* D3DXVec3UnprojectArray
*/
D3DXVECTOR3* WINAPI D3DXVec3UnprojectArray(
D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
CONST D3DVIEWPORT9* viewport, CONST D3DXMATRIX* projection,
CONST D3DXMATRIX* view, CONST D3DXMATRIX* world, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec3Unproject(
(D3DXVECTOR3*)((char*)out + outstride * i),
(CONST D3DXVECTOR3*)((const char*)in + instride * i),
viewport, projection, view, world);
}
return out;
}
/*************************************************************************
* D3DXVec4TransformArray
*/
D3DXVECTOR4* WINAPI D3DXVec4TransformArray(
D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR4* in, UINT instride,
CONST D3DXMATRIX* matrix, UINT elements)
{
unsigned int i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec4Transform(
(D3DXVECTOR4*)((char*)out + outstride * i),
(CONST D3DXVECTOR4*)((const char*)in + instride * i),
matrix);
}
return out;
}

9
include/d3dx9math.h
View File

@ -321,18 +321,26 @@ D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv0
D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pt1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pt2, FLOAT s);
D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv);
D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm);
D3DXVECTOR4* WINAPI D3DXVec2TransformArray(D3DXVECTOR4 *pout, UINT outstride, CONST D3DXVECTOR2 *pv, UINT vstride, CONST D3DXMATRIX *pm, UINT n);
D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm);
D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray(D3DXVECTOR2 *pout, UINT outstride, CONST D3DXVECTOR2 *pv, UINT vstride, CONST D3DXMATRIX *pm, UINT n);
D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm);
D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray(D3DXVECTOR2 *pout, UINT outstride, CONST D3DXVECTOR2 *pv, UINT vstride, CONST D3DXMATRIX *pm, UINT n);
D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT f, FLOAT g);
D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv0, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT s);
D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pt1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pt2, FLOAT s);
D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv);
D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT9 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld);
D3DXVECTOR3* WINAPI D3DXVec3ProjectArray(D3DXVECTOR3 *pout, UINT outstride, CONST D3DXVECTOR3 *pv, UINT vstride, CONST D3DVIEWPORT9 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld, UINT n);
D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm);
D3DXVECTOR4* WINAPI D3DXVec3TransformArray(D3DXVECTOR4 *pout, UINT outstride, CONST D3DXVECTOR3 *pv, UINT vstride, CONST D3DXMATRIX *pm, UINT n);
D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm);
D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray(D3DXVECTOR3 *pout, UINT outstride, CONST D3DXVECTOR3 *pv, UINT vstride, CONST D3DXMATRIX *pm, UINT n);
D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm);
D3DXVECTOR3* WINAPI D3DXVec3TransformNormalArray(D3DXVECTOR3 *pout, UINT outstride, CONST D3DXVECTOR3 *pv, UINT vstride, CONST D3DXMATRIX *pm, UINT n);
D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT9 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld);
D3DXVECTOR3* WINAPI D3DXVec3UnprojectArray(D3DXVECTOR3 *pout, UINT outstride, CONST D3DXVECTOR3 *pv, UINT vstride, CONST D3DVIEWPORT9 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld, UINT n);
D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT f, FLOAT g);
D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv0, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT s);
@ -340,6 +348,7 @@ D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CON
D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pt1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pt2, FLOAT s);
D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv);
D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, CONST D3DXMATRIX *pm);
D3DXVECTOR4* WINAPI D3DXVec4TransformArray(D3DXVECTOR4 *pout, UINT outstride, CONST D3DXVECTOR4 *pv, UINT vstride, CONST D3DXMATRIX *pm, UINT n);
#ifdef __cplusplus
}